python基础语法

第1、2章

1、变量名命名不能用数字开头，_代替空格

2、字符串使用单引号或双引号

注意：my name’s ZWH’，这是错误的！，此处要用双引号：”my name’s ZWH”。

一般单引号用于变量，双引号用于字符串。

3、让字母大小写的函数：.title()，.upper()，.lower()

name1 = 'Ada Lovelace'
print('单词首字母大写', name1.title())
print('单词全部大写', name1.upper())
print('单词全部小写', name1.lower())

4、f字符串：f” 字符串{变量}字符串”

在字符串中使用变量：f”{变量用花括号} 字符串直接写，且两者不需要逗号来分开！”

first_name = "ada"
last_name = "lovelace"
full_name = f"{first_name} {last_name}"
print(full_name)

5、数字运算：

**表示乘方，3 ** 3 = 27

6、数字很大可以用下划线分割

universe_age = 14_000_000_000

7、同时给多个变量赋值

x, y, z = 0, 1, 2
print(x, y, z)

第3章

1、固定的常量-全大写表示

2、访问列表最后一个元素，使用[-1]表示

bicycles = ['trek', 'cannodale', 'redline', 'specialized']
print(bicycles[-1])

3、修改列表元素 .append()

motorcycles = ['honda', 'yamaha', 'suzuki']
motorcycles[0] = 'ducati'
print(motorcycles)

4、添加列表元素

方法一：末尾添加元素，.append(‘’)

motorcycles = ['honda', 'yamaha', 'suzuki']
motorcycles.append('ducati2')
print(motorcycles)

方法二：任意位置添加元素，.insert(索引, ‘’)，添加的元素位置即为该索引，添加前其他原有元素右移一个位置

motorcycles = ['honda', 'yamaha', 'suzuki']
motorcycles.insert(0, 'ducati3')
print(motorcycles)

5、删除列表元素

方法一：.pop()删除末尾元素，并可得到该元素

motorcycles = ['honda', 'yamaha', 'suzuki']
poped_motorcycles = motorcycles.pop()
print("删除的元素：", poped_motorcycles)
print(motorcycles)

注意：.pop(索引)删除任何位置元素

方法二：删除任何位置元素，del 列表[索引]

motorcycles = ['honda', 'yamaha', 'suzuki']
del motorcycles[0]
print(motorcycles)

方法三：.remove()，根据内容删除，而非位置

motorcycles = ['honda', 'yamaha', 'suzuki']
motorcycles.remove('yamaha')
print(motorcycles)

6、排序列表元素

方法一：.sort()根据字母顺序排序（永久）

cars = ['bmw', 'audi', 'toyota', 'subaru']
print(cars)
cars.sort()
print(cars)

方法二：sorted(列表)，（临时）

cars1 = ['bmw', 'audi', 'toyota', 'subaru']
print("这句使用了sorted(列表)临时排序：", sorted(cars1))
print("不使用sorted(列表)后，现在打印cars1仍为：", cars1)
# 这里sorted(cars1))为排序好的列表，而cars1仍为原来的列表

方法三：.reverse()，只是倒着打印列表元素，不会根据字母大小排序！

cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.reverse()
print(cars)

7、确定列表长度

len(列表)，用来知道列表的长度

cars = ['bmw', 'audi', 'toyota', 'subaru']
print("cars列表长度为：", len(cars), "即0~3或0~-1")

第4章

1、 for循环打印列表元素

dogs = ['alice', 'david', 'carolina']
for dog in dogs:
    print(dog)

每次循环把dogs的元素赋值给dog，然后通过print打印出来。

命名规则：用dog和dogs命名很不错的，也有item和list_of_items

2、range(1, x)，依次生成1、2、3、x-1：1~x-1

for value in range(1, 5):
    print(value)
#依次生成1、2、3、4数字

range()创建数字列表

numbers = list(range(1, 6))
print(numbers)

range(1, x, n)，从1开始，然后不断加n，直到达到或超过终值x

even_numbers = list(range(2, 11, 2))
print(even_numbers)

3、列表解析，将几行代码整合成一行

原来代码：

squares = []
for value in range(1, 11):
    value = value ** 2
    squares.append(value)
print(squares)
# 结果：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

列表解析后：

squares = [value ** 2 for value in range(1, 11)]
print(squares)
# 结果：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

如果for循环里有if，位置放后面，具体百度

4、切片，列表[M:N]，为第M+1到第N个元素组成的元素

例子：在游戏的作用：所有玩家的得分加入一个列表中，然后列表按降序排列，用切片截取前三名化为一个小列表。

players = ['charles', 'florence', 'martina', 'michae', 'eli']
print(f"第二个到第四个元素组成的列表：{players[1:4]}")
print(f"第二个到最后一个元素组成的列表：{players[1:]}")

[1:]和[1:-1]不一样！切片-1表示倒数第二个元素
同理,[:3]表示第一个到第三个元素：0 1 2

print(f"第二个到最后一个元素组成的列表：{players[1:-1]}")
for player in players[:3]:
    print(player)

切片复制列表

my_foods = ['pizza', 'falafel', 'carrot cake']
friend_foods = my_foods[:]
#friend_foods列表内容复制了my_foods列表
print("我最爱的食物是：", my_foods)
print("朋友最爱的食物是：", friend_foods)

疑问：为什么不能直接用friend_foods = my_foods呢？

这里是两者同生共死了，两个列表不能添加不同元素，而是两者都添加不同的元素

my_foods = ['pizza', 'falafel', 'carrot cake']
friend_foods = my_foods
my_foods.append('ice cream')
friend_foods.append('cannoli')
print("我最爱的食物是：", my_foods)
print("朋友最爱的食物是：", friend_foods)
# 结果：
我最爱的食物是： ['pizza', 'falafel', 'carrot cake', 'ice cream', 'cannoli']
朋友最爱的食物是： ['pizza', 'falafel', 'carrot cake', 'ice cream', 'cannoli']

5、元组：不可修改的列表，定义元组用()而非[]，索引仍用[]

例子：一个大小不应该变的矩形，长和宽存储在一个元组中

dimensions = (250, 50)
print("矩形长度为：", dimensions[0])
print("矩形宽度为：", dimensions[1])

6、列表查询是否有某个元素：in

‘元素’ in 列表

requested_toppings = ['mushrooms', 'onions', 'pineapple']
print('mushrooms' in requested_toppings)
print('pepperoni' in requested_toppings)
# 结果：
True
False

7、列表查询是否没有某个元素： not in

‘元素’ not in 列表

requested_toppings = ['mushrooms', 'onions', 'pineapple']
print('pepperoni' not in requested_toppings)
# 结果：True

第5章：if语句

1、if-elif-else结构

例子：定义4岁以下门票0元，418以下门票25元，1865以下40元，65且以上20元。

age = 12
if age < 4:
    cost = 0
elif age < 18:
    cost = 25
elif age < 65:
    cost = 40
else:
    cost = 20
print(f"Your admission cost is {cost}")
# 结果：Your admission cost is 25

2、for、if循环和in检查合用

available_nums = ['1', '2', '3', '4', '5']
requested_nums = ['2', '4', '7']
for requested_num in requested_nums:
    if requested_num in available_nums:
        print("你要的数字有多余的")
    else:
        print("你要的数字没有")
# 结果：
你要的数字有多余的
你要的数字有多余的
你要的数字没有

第6章：字典

1、字典定义,使用花括号

字典名 = {‘’: ‘’, ‘’: ‘’}

创建空字典：字典名 = {}

字典是一系列的键值对，指定键时，Python返回的是相关联的值，采用花括号！

alien_0 = {'color': 'green', 'points': 5}

2、访问字典

方法一：.get()

get()访问值：字典名.get(‘键’, ‘键不存在则返回这个字符串’)

point_value = alien_0.get('points', '字典没有points这个键')
x_position_value = alien_0.get('x_position', '字典没有x_position这个键')
print(point_value)
print(x_position_value)
# 结果：
5
字典没有x_position这个键

方法二：直接通过键来访问值，缺点：该值必须存在

print(alien_0['color'])
print(alien_0['points'])
# 结果：
green
5

3、添加键值对： 字名[‘键’] = 值

alien_0['x_position'] = 0
alien_0['y_position'] = 25

4、修改字典中的值

alien_0['color'] = 'red'

5、删除键值对： del 语句

del alien_0['color']

6、遍历字典

# 先定义一个字典
favorite_languages = {
    'jen': 'Python',
    'sarah': 'C',
    'edward': 'Java',
    'phil': 'Ruby',
    'div': 'Java'
}

for循环遍历，需要用两个变量，分别存储字典的键和值

字典名.items()：是返回所有键值对的一个列表

for name, language in favorite_languages.items():
    print("\n名字：", name)
    print("喜爱的语言：", language)
# 结果：
名字： jen
喜爱的语言： Python

名字： sarah
喜爱的语言： C

名字： edward
喜爱的语言： Java

名字： phil
喜爱的语言： Ruby

名字： div
喜爱的语言： Java

字典名.keys()：是返回所有键的一个列表

for name in favorite_languages.keys():
    print(name)
# 结果：
jen
sarah
edward
phil
div

都不带，则默认返回的也是键，但用key方法可让代码更容易

for name in favorite_languages:
    print(name)
# 结果：
jen
sarah
edward
phil
div

字典名.values()：返回所有值的一个列表

for value in favorite_languages.values():
    print(value)
# 结果：
Python
C
Java
Ruby
Java

正常情况下，值有很多一样的，上面方法会死板地遍历所有值，可通过集合set来剔除重复项。

集合中的每个元素都是独一无二的，对含重复项的列表调用set(),可找出列表独一无二的元素，并由此创建一个集合。

#升级版。常用
for value in set(favorite_languages.values()):
    print(value)
#结果：
C
Ruby
Java
Python

使用sorted()顺序遍历所有键

for name in sorted(favorite_languages.keys()):
    print(name)
# 结果：
div
edward
jen
phil
sarah

7、集合和字典区别

集合创建 languages = {‘Python’, ‘Ruby’, ‘C’}

集合和字典的相同点：都使用花括号，不同点：字典是键值对，一对一，而集合是单个

8、嵌套（字典作为列表的元素，或者相反，或者字典嵌套字典等）

在列表中存储字典

# 先定义三个外星人字典
alien_0 = {'color': 'green', 'points': 5}
alien_1 = {'color': 'red', 'points': 10}
alien_2 = {'color': 'yellow', 'points': 20}

# 保存在一个外星人列表中
aliens = [alien_0, alien_1, alien_2]
for alien in aliens:
    print(alien)
    
结果：
{'color': 'green', 'points': 5}
{'color': 'red', 'points': 10}
{'color': 'yellow', 'points': 20}

在字典中存储列表

# 值变成列表
favorite_languages = {
    'jen': ['Python', 'Ruby'],
    'edward': ['Java', 'C'],
    'phil': ['Python', 'Go'],
}

for k, v in favorite_languages.items():
    print(k)
    print(v)
    
结果：
jen
['Python', 'Ruby']
edward
['Java', 'C']
phil
['Python', 'Go']

第7章：用户输入和while循环

1、input()，输入值变为字符串

name = input("Please enter your name:  ")
print("Hello!", name)

提示输入的信息超过一行，可通过先赋给变量的方法间接

prompt = "If you tell us who you are, we can personalize the messages you see."
prompt += "\nWhat is your first name?"
name = input(prompt)
print("Hello!", name)

使用int()来将输入值转换为数值

# age = input("How old are you? ")
age = int(age)
# 此时输入的age由字符串变为数值，可以进行条件比较
age >= 18

2、while循环

current_number = 1
while current_number <= 5:
    print(current_number)
    current_number += 1

3、标志：当多个条件都可以让游戏结束时，该怎么用while呢？，使用标志

下面添加一个标志，命名为active，你可给它指定任何名称

prompt = "Enter 'quit' to end the game: "
active = True
while active:
    message = input(prompt)
    if message == 'quit':
        active =False
    else:
        print(message)

使用break退出循环

continue可重新回到循环开头，不在执行循环中下面的语句

来看一个从1到10，但只打印奇数的循环

current_number = 0
while current_number < 10:
    current_number += 1
    if current_number % 2 == 0:
        continue

    print(f"1~10中奇数共有：{current_number}")

4、列表元素到另一个列表

未验证的用户表 -> 已验证的用户表

uncofirmed_users = ['alice', 'brian', 'candace']
confirmed_users = []

while uncofirmed_users:
    # uncofirmed_users列表有元素，就一直为True
    v = uncofirmed_users.pop()
    # pop：将列表最后一个元素踢出来
    print("正在验证的用户：", v)
    confirmed_users.append(v)

for confirmed_user in confirmed_users:
    print("已验证好的用户: ", confirmed_user)

5、删除列表的某个特定值，重复的也一并删除

pets = ['dog', 'cat', 'dog', 'rabbit', 'cat']

while 'cat' in pets:
    pets.remove('cat')
print(pets)

6、使用用户输入来填充字典

responses = {}
# 空字典
polling_active = True
# 标志，当用户输入no时可以退出循环（即不用在输入）

while polling_active:
    name = input("\nWhat is Your name? :")
    response = input("Which mountain would you like to climb someday? ")

    responses[name] = response
    # 将回答存储在字典中
    #name为键，response为值
    repeat = input("Would you like to let another person respond? (yes/ no) ")
    if repeat == 'no':
        polling_active = False

for name, response in responses.items():
    print(f"{name} would like to climb {response}.")

第8章：函数

1、定义函数

def greet_user():
    print("你好，函数")

greet_user()

2、传递信息，实参和形参

def greet_user(username):
    print("你好，函数。你好，",username)

greet_user('Casimi')

通过添加username，可让函数接受你给的username指定的任何值。

username为形参（parameter）

‘Casimi’为实参（argument）

3、传递实参

def describe_pet(animal_type, pet_name):
    print(f"\nI have a {animal_type}.")
    print(f"My {animal_type}'s name is {pet_name}")

位置实参：形参和实参必须一一对应。

describe_pet('harry', 'huihui')

关键字实参：相比于位置实参的死板，通过将形参和实参相关联，不仅不用考虑实参顺序位置，而且还清楚指出函数调用中各个值的用途，以下不按照顺序位置均可以。

describe_pet(animal_type='harry', pet_name='mimi')
describe_pet(pet_name='mimi2', animal_type='harry')

默认值：重复指定相同的实参时，可在形参中将该重复值设置为默认值。

# 如想描述很多小狗类型时，可将animal_type的dog设置默认值
def describe_pet(pet_name, animal_type='dog'):
    # 注意！设置默认值的形参必须排在最后面！pet_name排在后面会报错
    print(f"\nI have a {animal_type}.")
    print(f"My {animal_type}'s name is {pet_name}")

describe_pet(pet_name='xiao')
describe_pet(pet_name='bai')
describe_pet(pet_name='baibai', animal_type='cat')
# 在调用函数时，默认值的animal_type也可以改变！

4、等效的函数调用

def describe_pet(pet_name, animal_type='dog'):
    print(f"\nI have a {animal_type}.")
    print(f"My {animal_type}'s name is {pet_name}")

# 一只名为willie的小狗
describe_pet('whille') #位置调用
describe_pet(pet_name='whille') #关键字调用

# 一只名为Harry的猫（不用默认值dog）
describe_pet('harry', 'cat') #位置调用
describe_pet(pet_name='harry', animal_type='cat') #关键字调用
describe_pet(animal_type='cat', pet_name='harry')

5、返回字典

def build_person(first_name, last_name):
    person = {'first': first_name, 'last': last_name}
    return person

musician = build_person('jimi', 'hendrix')
print(musician)

扩展：使其接受年龄，职业等要存储的信息，下面以存储年龄为例

def build_person(first_name, last_name, age=None):
    #默认值age设置为特殊值None，表示什么也没有，且None相当于False
    person = {'first': first_name, 'last': last_name}
    if age:
    #age有实参值的话，就是True，即会执行if语句
        person['age'] = age
    return person

musician = build_person('jimi', 'hendrix',age=27)
print(musician)

例子：设计一个输入姓和名，弹出欢迎语句。

# 函数+while循环，且可随时退出
def get_formatted_name(first_name, last_name):
    full_name = f"{first_name} {last_name}"
    # 也可以full_name = first_name + '' + last_name
    return full_name.title()
    
    
while True:
    print("\n请输入你的姓和名")
    print("可随时输入q来退出")

    f_name = input("请输入你的姓")
    if f_name == 'q':
        break

    l_name = input("请输入你的名")
    if l_name == 'q':
        break

    user_name = get_formatted_name(f_name, l_name)
    print(f"\n你好，{user_name}")

5、传递列表

def greet_users(names):
    """向列表中的每一位用户发出问候"""
    for name in names:
        print(f"你好啊，{name.title()}")


user_names = ['jack', 'john', 'moshi']
greet_users(user_names)

在函数中修改列表：

对于列表处理时，操作过多可用函数来独立负责某一个功能

def print_models(unprinted_designs, completed_models):
    """"
    模拟打印每个设计，直到没有未打印的设计为止。
    打印每个设计后，都将其移到列表completed_models中。
    """
    while unprinted_designs:
        current_desing = unprinted_designs.pop()
        print(f"正在打印：{current_desing}")
        completed_models.append(current_desing)

def show_completed_models(comleted_models):
    """显示打印好的所有模型"""
    print("\nThe following models have been printed:")
    for comleted_model in comleted_models:
        print(comleted_model)

unprinted_designs  = ['phone case', 'robot pendant', 'dodecahedron']
completed_models = []

print_models(unprinted_designs, completed_models)
show_completed_models(completed_models)

禁止函数修改列表：

上述代码执行后，unprinted_designs列表的元素删除了（pop删除并赋值），

可通过function_name(list_name[:])（切片）来创建unprinted_designs列表的副本。

print_models(unprinted_designs[:], completed_models)

6、传递任意数量的实参

有时不清楚该形参会传递多少个实参，就用该格式:函数名(*形参名)

以下披萨不清楚顾客放哪种配料，但都属于配料topping，可用*topping

# 传递过来的实参都放在一个元组中，如('pepperoni')或('mushrooms', 'green peppers', 'extra cheese')
def  make_pizza(*toppings):
    for topping in toppings:
        print(topping)

make_pizza('pepperoni')
print("----分割线----")
make_pizza('mushrooms', 'green peppers', 'extra cheese')

结合位置实参和任意数量的实参：

同样放在最后面，且此处按照位置，16对应size，后面都对应*toppings

def make_pizza(size, *toppings):
    print(f"制作一个{size}的披萨需要的配料为：")
    for topping in toppings:
        print(topping)

make_pizza(14, 'pepperoni')
make_pizza(16, 'mushrooms', 'green peppers', 'extra cheese')

使用任意数量的关键字实参：

使用**形参，来表示任意数量的名称值对,**形参中的**让Python创建一个名为形参的空字典

def build_profile(first, last, **user_info):
    """创建一个字典，其中包含我们所知道的有关用户的一切"""
    # 字典添加键值对的操作，这里first_name为键，first即调用函数输入的实参为值
    user_info['first_name'] = first
    user_info['last_name'] = last
    return user_info
    #调用函数输入实参后，return了user_info这个字典，方便赋值给新变量user_profile

user_profile= build_profile('Jack', 'Hans', age=12,location='princeton')
print(user_profile)

7、将函数存储在模块中（即.py文件中）

7.1 导入整个模块 （太麻烦，建议用8.6.5的升级版）：

import 文件名：
导入后使用方法：文件名.函数名() module_name.function_name()
觉得每次使用函数多要加文件名太麻烦？看7.5
这种会将该文件的所有函数复制到程序中，只是我们看不见。

7.2 导入模块的特定函数：
from module_name import function_name
form module_name import function_name_0, function_name_1, function_name_3
导入后使用方法：直接使用，即function_name()

7.3 使用as给导入的函数改名：
导入的函数名可能和本程序的函数重名，这时可用as改名
接7.2的导入，from module_name import function_name as 其他名
改名后使用改名后的名字

7.4 使用as给导入的模块改名：
import module_name as 其他名

7.5 导入模块中的所有函数：
使用*
from module_name import *
导入后使用方法：直接使用，即function_name()

第9章：类

这里开始不做笔记了，有些java基础，看就完事了