py学习日记

From：《python编程从入门到实践》

持续更新中...

都在代码里了

第一到七章：

"""
Author:CruelKing
Time:7/27/2019/morning
Name:py基本语法练习

"""

def main():
    message = 'hello world'
    print(message)
    print(message.title()) # 通过title()函数将输出的每个单词的第一个字母改为大写形式
    print(message.upper()) # 通过upper()函数将输出的所有字符以大写的形式输出
    print(message.lower()) # 通过lower()函数将输出的所有字符以小写的形式输出
    first_name = 'bian'
    last_name = 'junting'
    full_name = last_name + ' ' + first_name # python中通过 '+'将两个字符串或者字符拼接起来
    print(full_name)
    print('Hello, ' + full_name.title() + "!") # 上述两种特性的灵活应用,也可以使用一个新的变量存储合并之后的字符串
    
    print('languages:
python
c
c++
javascript') # 使用
, 	等可以使得字符串中增加换行或者tab

    language_type = ' python '
    print(language_type)
    print('.' + language_type.strip() + '.') #用strip()函数去除字符串头和尾的空格
    print('.' + language_type.lstrip() + '.') #用lstrip()函数去除字符串头部的空格
    print('.' + language_type.rstrip() + '.') #用rstrip()函数去除字符串尾部的空格

    string = "python is a 'language'" #在需要使用单引号的情况下要以双引号表示字符串，反之使用单引号表示，如果未出现需要表示单双引号的情况则两种都可以
    print(string)
    
    age = 23
    print('happy ' + str(age) + 'rd Birthday') #在python中使用str()函数使得一个整数变为字符串
    floatage = 23.234
    print(str(floatage)) # print as a string and it is '23.234'

    num1 = 3 / 2 # 表示浮点数除法
    print(num1)
    num2 = 3 // 2 # 表示整数除法
    print(num2)
    print("%.2f" % (num1)) # 表示小数点后保留两位有效数字
    
# 列表
    bicycles = ['trek', 'cannondale', 'redline', 'specialized']
    print(bicycles) # 这种打印方式会打印列表的内部表示
    
    print(bicycles[0])
    print(bicycles[-3].title())
    print(bicycles[1].upper())
    print(bicycles[-2].lower())
    print(bicycles[3].strip())
    print(bicycles[-1].lstrip()) # python中使用-1表示列表中最后一个元素的索引
    bicycles[0] = 'ducati' # 通过索引直接修改指定位置的值
    print(bicycles[0])
    
    print(bicycles)
    bicycles.append('ducati')
    print(bicycles) # 通过append()向列表尾部添加元素
    bicycles.insert(0, 'ducati') # 通过insert()向列表的第0个位置插入一个元素'ducati'
    print(bicycles)
    
    del bicycles[0] # 删除列表第0个位置的元素
    print(bicycles)
    motorcycles = ['honda', 'yamaha', 'suzuki']
    print(motorcycles)
    
    poped_motorcycle = motorcycles.pop() # 通过pop()删除列表中的元素并且将这个元素赋值给另一个同类型的元素
    print(motorcycles)
    print(poped_motorcycle)
    first_owned = motorcycles.pop(1) # 通过pop(1)删除列表中第1个位置的元素并且将这个元素赋值给另一个同类型的元素
    print('The first motorcycle I owned was a ' + first_owned.title() + '.')
    
    motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati', 'suzuki', 'ducati']
    print(motorcycles)
    motorcycles.remove('ducati') # 通过remove('ducati')将列表中从前往后出现的第一个名为'ducati'的元素删除，可使用循环实现全部删除，romove()删除的元素也可以赋值给同类型的其他元素
    print(motorcycles)
    
    cars = ['bmw', 'audi', 'toyota', 'subaru']
    cars.sort() #通过sort()函数将列表按照字典序从小到大排序
    print(cars)
    cars.sort(reverse = True) # 通过reverse = True使得列表按照字典序从大到小排序
    print(cars)

    cars = ['bmw', 'audi', 'toyota', 'subaru']
    print(cars)
    print(sorted(cars)) # 通过sorted()函数使得cars内部的元素变得暂时有序并输出，但其实并不会影响cars内部的元素
    print(cars)
    print(sorted(cars, reverse = True)) # 递减序输出
    print(cars)
    
    print(cars)
    cars.reverse() # 将列表元素反转
    print(cars)

    print(len(cars)) # 输出列表长度

# for in 循环遍历整个列表：
    magicians = ['alice', 'david', 'carolina']
    for magician in magicians: # 一般使用名词复数形式表示整个列表，用单个名词代表单个元素
        print(magician)
        print(magician.title() + ', that was a great trick!')

# 创建数字列表
    for value in range(1, 5): # 生成1-4的字典序最小的全排列数字
        print(value)

# 使用range()创建数字列表
    numbers = list(range(1, 6)) # 创建了一个元素为1~5的数字列表
    print(numbers)
    numbers = list(range(1, 6, 2)) # 可以指定步长为2
    print(numbers)

# 使用range()创建一个列表，包含前十个数的平方
    squares = []
    for value in range(1, 11):
        square = value ** 2
        squares.append(square)
    print(squares)
    print(sum(squares)) # sum表示对列表求和的结果
    print(min(squares)) # min表示一个列表中最小的元素
    print(max(squares)) # max表示一个列表中最大的元素

# 列表解析
    squares = [value ** 2 for value in range(1, 11)]
    print(squares)

# 切片：使用列表的一部分
    # 即使列表的长度发生变化输出依然为下面所描述的那样
    players = ['charles', 'martina', 'michael', 'florence', 'eli']
    print(players[0:3]) #输出第一个到第三个人的名称
    print(players[1:4]) #输出第二个人到第四个人的名称
    print(players[3:]) #输出第四个人及后面所有人的名称
    print(players[:3]) #输出第三个人及前面所有人的名称
    print(players[-3:]) #输出最后三名队员的名称
    
    # 遍历切片
    for player in players[0:3]: # 使用for in 语句遍历这个切片
        print(player.title())
    
    # 复制列表
    my_foods = ['pizza', 'falafel', 'carrot cake']
    friend_foods = my_foods[:] # 通过将切片前后范围都省略从而将整个列表重新复制到另一个列表中，不能直接使用等于号复制列表
    print(my_foods)
    print(friend_foods)

# 元组：不可变列表
    #顾名思义就是列表中的值不可改变，定义列表时使用圆括号而非方括号,使用元组中的元素时使用方括号
    dimensions = (200, 50)
    print(dimensions[0])
    print(dimensions[1])
    
    # 遍历元组的所有值
    for dimension in dimensions:
        print(dimension)
    
    # 修改元组变量
    dimensions = (200, 50)
    for dimension in dimensions:
        print(dimension)
    dimensions = (400, 10) #可以重新定义以修改元组的值，但不可以修改元组内某一个值，比如demensions[0] = 100是不可取的
    for dimension in dimensions:
        print(dimension)

# 条件判断语句
    leap_years = []
    for value in range(1, 2019):
        if(value % 4 == 0 and value % 100 != 0 or value % 400 == 0): # 使用 and 语句表示逻辑与，or表示逻辑或
            leap_years.append(value)
    print(len(leap_years))
    print(leap_years)
    year = 92
    if year in leap_years: # 使用in关键字判断某个值是否包含在某个数组或者元组中，not in为不包含
        print('%d is leapyears' % (year))

# 布尔表达式
    is_sun = True
    is_snow = False
    if is_sun:
        print('Today is warm!')
    if is_snow:
        print('Today is cold!')
    
# 判断列表是否为空
    requested_toppings = []
    if requested_toppings: # 使用if + 列表名 判断是否列表中是否有元素
        for requested_topping in requested_toppings:
            print('Adding ' + requested_topping + '.')
        print('
Finished making your pizza!')
    else:
        print("Are you sure you want to a plain pizza?")


# 字典
    my_friend = {
            'first_name' : 'li',
            'last_name' : 'hong jiang',
            'age' : 21,
            'city' : 'xianshaanxi'
            }
    my_friend['is_passed_cet6'] = True # 向字典my_friend中添加元素
    my_friend_name = my_friend['last_name'] + my_friend['first_name'] # 访问字典中的元素
    print(my_friend_name)
    print("My friend's name is " + str(my_friend['age']))
    print(my_friend)
    
    print(my_friend['age'])
    my_friend['age'] = 23 # 通过赋值语句修改字典中某key所对应的value
    print(my_friend['age'])
    
    print(my_friend)
    del my_friend['is_passed_cet6'] # 通过删除语句永久删除字典中某个key和他所对应的value
    print(my_friend)

# 通过字典实现简单词汇表
    vocabularys = {
            'Abandon' : '放弃',
            'Monday' :'星期一',
            'Tuesday' : '星期二',
            'Wednesday' : '星期三',
            'Thursday' : '星期四',
            'Give_up' : '放弃',
            }
    print(vocabularys['Abandon'])
    print(vocabularys['Monday'])
    print(vocabularys['Thursday'])

# 使用for in 语句实现对字典中所有key和value的访问
    for vocabulary, translate in vocabularys.items():
        print("The means of " + vocabulary +  " is " + translate + '.')

# 遍历字典中的所有键
    for vocabulary in vocabularys.keys():
        print(vocabulary.title())

# 也可以使用in和not in判断某个key是否为改字典中的key
    if 'Friday' not in vocabularys.keys():
        print('Friday is not in vocabularys')

# 也可以使用sorted()函数使得字典中的所有key按照字典序递增序被访问
    for vocabulary in sorted(vocabularys.keys()):
        print(vocabulary)

# 遍历字典中的所有值
    for value in vocabularys.values():
        print(value)

# 可以使用集合set排除value中的重复元素
    for value in set(vocabularys.values()):
        print(value.title())

# 嵌套
    # 字典列表
    alien_0 = {
            'color' : 'green',
            'points' : 5,
            }
    alien_1 = {
            'color' :'green',
            'points' : 5,
            }
    alien_2 = {
            'color' : ' green',
            'points' : 5,
            }
    aliens = [alien_0, alien_1, alien_2]
    for alien in aliens:
        print(alien)

    # 使用for语句生成多个外星人
    for alien_number in range(30):
        new_alien = {
                'color' : 'green',
                'points' : 5,
                }
        aliens.append(new_alien)
    # 输出前五个机器人的信息
    for alien in aliens[:5]:
        print(alien)
    
    # 在字典中存储列表
    favorite_languages = {
            'jen' : ['python', 'ruby'],
            'sarah': ['ruby', 'go'],
            'phil' : ['python', 'haskell'],
            'edward' : ['c'],
            }
    for name, languages in favorite_languages.items():
        print('
' + name.title() + "'s favoriete languages are:")
        for language in languages:
            print("	" + language.title())

    # 字典嵌套字典
    users = {
            'aeinstein': {
                'first' : 'albert',
                'last' : 'einstein',
                'location' : 'princeton',
                },
            'mcurie' : {
                'first' : 'marie',
                'last' : 'curie',
                'location' : 'pairs',
                },

            }
    for username, user_info in users.items():
        print('
Username:' + username)
        full_name = user_info['first'] + ' ' + user_info['last']
        location = user_info['location']

        print('t Full_name :' + full_name.title())
        print("	 Location: " + location.title())

# while循环
    #使用while循环删除列表中特定值的所有元素
    pets = ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat']
    print(pets)
    while 'cat' in pets:
        pets.remove('cat') # 使用列表中的remove()函数删除列表中值为'cat'的元素
    print(pets)
    
    #使用用户输入来填充字典
    responses = {}
    polling_active = True
    while polling_active:
        name = input('
What is your name?')
        response = input('Which mountain would you like to climb someday')

        responses[name] = response # 向字典中添加一对值

        repeat = input('Would you like to let another person respong?(yes, no)')
        if repeat == 'no':
            polling_active = False
    print('
 --- Poll Pesults ---')
    for name, response in responses.items():
        print(name + 'Would like to climb' + response + '.')

if __name__ == '__main__':
    main()

第八章函数调用基本操作：

def main():
    a = int(input('a = '))
    b = int(input('b = '))
    print_sum_of_two_numbers(a, b) # 此处传入的参数为位置实参，传入位置实参时要特别注意传入参数的顺序要符合原本函数形参的顺序
    print_sum_of_two_numbers(x = a, y = b) # 此处传入的参数为关键字实参，通过函数中形参的名称与需要传入的实参一一对应，完成函数调用
    print_sum_of_two_numbers(x = 3) # 函数形参可以添加默认值，未传入实参的参数则按照形参的值进行相关运算
    
    numbers = [1, 2, 3, 4, 6]
    sum =  get_sum(numbers)
    print(sum)
    print(numbers)
    change_list(numbers[1:4])
    print(numbers)
    make_pizza1('mushrooms', 'green peppers', 'extra cheese')
    make_pizza2(18, 'pepperoni')
    user_profile = build_profile('albert', 'einstein', location = 'princeton', field = 'physics')
    print(user_profile)

def print_sum_of_two_numbers(x = 0, y = 0):
    print(x + y) 

# 使用''空字符串将middle_name初始化，if语句对空字符串判断返回False，因此函数就可以根据用户的输入情况给出对应的正确的输出
def got_formatted_name(first_name, last_name, middle_name = ""):
    if middle_name:
        full_name = first_name + ' ' + middle_name + ' ' + last_name
    else:
        full_name = first_name + ' ' + last_name
    return full_name

# 函数可以返回任意类型的值，字典元组列表集合等都可
def build_person(first_name, last_name):
    person = {
            'first' : first_name,
            'last' : last_name,
            }
    return person

# 向函数传递一个列表作为实参，可以函数内修改列表内的值，且为永久修改
def get_sum(numbers):
    sum = 0
    for number in numbers:
        sum += number
    return sum

# 如果想要避免函数修改列表的值，那么就可以传递列表的切片即可
def change_list(numbers):
    for number in numbers:
        print(number)

# 传递任意数量的参数
def make_pizza1(*toppings): # 通过形参名*toppings让python创建一个名为toppings的空元组，并接受调用函数时所给的实参
    for topping in toppings:
        print('---' + topping)

# 结合使用位置实参和任意数量实参
def make_pizza2(size, *toppings): # 第一个参数必须为大小，第二个参数为其他参数
    print('
Making a ' + str(size) + '-inch pizza with the following toppings:')
    for topping in toppings:
        print('-' + topping)

# 使用任意数量的关键字实参
def build_profile(first, last, **user_info): # 形参**user_info让python建立一个空字典
    profile = {}
    profile['first_name'] = first
    profile['last_name'] = last
    for key, value in user_info.items():
        profile[key] = value
    return profile


if __name__ == '__main__':
    main()

将函数导入模块，使用模块中的制定函数：

import function # 通过import语句可以调用function模块内的所有函数，通过模块名.函数名访问某个函数
from function import build_profile, get_sum # 通过from import语句导入某个文件中的某个函数，可通过函数名直接访问
from function import build_person as bp # 使用as给函数制定别名
import message as m # 使用as给模块指定别名，但是调用时需要使用模块名.函数名访问某个函数
from pizza import * # 使用*导入模块中的所有函数，导入之后的函数可以直接通过名称使用而不需要通过模块.函数名的方式使用

def main():
    user_profile = function.build_profile('albert', 'einstein', location = 'princeton', field = 'physics')
    print(user_profile)
    numbers = [1, 2, 3, 4]  
    sum = get_sum(numbers)
    print(sum)
    person = bp('jimi', 'hendrix')
    print(person)

if __name__ == '__main__':
    main()

python3中的基本输入输出：

def main():
    # 多组输入模板
    """
    while True:
        try:
            numbers = list(map(int, input().split())) # split()是分割函数，将字符串以字符c分割，c默认值为空格，返回值为字符串，map函数将字符串按照指定类型映射到列表中
            ans = 0
            for number in numbers:
                ans += number
            print(ans)
        except EOFError:
            break
    t = int(input())
    for _ in range(t):
        numbers = list(map(int, input().split()))
        ans = 0
        for number in numbers:
            ans += number
        print(ans)
    """


if __name__ == '__main__':
        main()