1 f格式化字符串

name = '王鑫'
age = 88
print(f'名字{name}, 年龄{age + 1}')

2 复合赋值注意点

a = 10
a *= 1 + 2 # 结果为30

3 条件判断

3.1 条件写法拓展

age >= 8 and age <= 60 可简写为 8 <= age <= 60

3.2 三目运算符

a = 1
b = 2
c = a - b if a > b else b - a  # c = 1

4 循环

4.1 while循环中的continue语句注意点

i = 1
while i <= 5:
  if i == 3:
    print("不吃这个，吃下一个")
    i += 1  # 如果使用continue，其之前一定要修改计数器，否则进入死循环
    continue
  print(f"吃了第{i}个")
  i += 1

4.2 while...else...使用及for...else...使用

i = 1
while i <= 5:
  if i == 3:
    break
  i += 1
else:
  print("循环正常结束")  # 不会打印

i = 1
while i <= 5:
  if i == 3:
    i += 1
    continue
  i += 1
else:
  print("循环正常结束")  # 会打印

for i in "csagh":
  if i == "a":
    break
else:
  print("循环正常结束")  # 不会打印

for i in "csagh":
  if i == "a":
    continue
else:
  print("循环正常结束")  # 会打印

5 字符串

5.1 find和index，查找子串（可指定起始位置），子串不存在find返回-1，index报错（rfind和rindex为从右向左查找，用法相同）

str = "python and django and redis"

str.find('and', 17, 22) # 18
str.index('and', 17, 22) # 18

str.find('ands', 17, 22) # -1
str.index('ands', 17, 22) # 报错

str.rfind('and') # 18
str.rindex('and', 0, 22) # 18

5.2 count，统计子串出现次数（可指定起始位置）

str.count('and')  # 2
str.count('ands')  # 0

5.3 replace，注：方法返回新串，不修改原字符串

str.replace('and')  # 全部替换
str.replace('and', 1)  # 从左到右替换1次
str.replace('and', 10)  # 大于子串出现次数，全部替换

5.4 split

str.split('and', 1)  # ['python ', ' django and redis']

5.5 join

'...'.join(str.split('and'))  # "python ... django ... redis"

5.6 capitalize(整个字符串首字母大写)，title(每个单词首字母大写)，upper(全部大写)，lower(全部小写)

5.7 strip，lstrip，rstrip删除空白字符

5.8 ljust，rjust，center对齐方式

mystr = 'hello'
mystr.ljust(10, '*')  # 'hello*****'
mystr.rjust(10, '*')  # '*****hello'
mystr.center(10, '*')  # '**hello***'

5.9 startwith，endwith

mystr.startswith('hel')  # True
mystr.endswith('ll', 0, 4)  # True

5.10 isalpha(字母), isdigit(数字), isalnum(字母或数字或两者组合), isspace(空格)

6 列表

6.1 列表判断元素是否存在(in, not in)

l = [1, 2, 3]
2 in l  # True
4 not in l  # True

6.2 extend在追加数据时，会将数据序列拆开逐一追加

l = ['wx', 'yxx']
l.extend('xiaoming')  # 追加单个字符串用append，extend追加数组合并两个数组元素
print(l)  # ['wx', 'yxx', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']

6.3 列表中，del删除变量或指定下标数据，pop删除指定下标数据，不指定下标，默认删除最后一个数据，remove删除数组中指定数据(若匹配到多个只删除匹配到的第一个), clear清空数组

l = ['w', 's', 'f']
del l[0]  # ['s', 'f']
l.pop(1)  # ['w', 'f']
l.pop()  # ['w', 's']
l.remove('s')  # ['w', 'f']
l.clear()  # []

6.4 列表+=底层为extend（l += [1, 2]不等于l = l + [1, 2]）

a = [1]
a += '23'  # [1, '2', '3']
a = a + '45'  # 报错

6.5 切片（也适用于字符串切片）

l = [1, 2, 3, 4, 5]
print(l[::-1] ) # [5, 4, 3, 2, 1]
print(l[-3:-1:-1])  # []
print(l[-1:-3:-1])  # [5, 4]
# 步长为负数，从右往左选

7 元组

7.1 元组中只有一个元素时，一定要加个逗号隔开

a = (1,)
type(a)  # tuple
b = ('aaa')
type(b)  # str

7.2 注意点

a = 1, 2  # 直接赋值a保存的是元组
print(a)  # (1, 2)
a = 1,  # 注意这里赋值的逗号，a还是元组
print(a)  # (1,)
a, b = 10, 20
a, b = b, a  # 等同于 a, b = (b, a)，交换两个变量值

8 字典

8.1 字典方法get

d = {'name': 'zhangsan', 'age': 22}
d.get('name')  # zhangsan
d.get('id', 110)  # 110
d.get('id')  # None

8.2 拆包遍历字典键值对

d = {'name': 'zhangsan', 'age': 22}
for key, value in d:
  print(f'{key}={value}')

8.3 字典相关注意点

d = {'name': 'zhangsan', 'age': 22}
for i in d:  # 直接遍历字典，其实遍历的是字典的键
  print(i)  # {'name', 'age'}

a, b = {'aaa': 1, 'bbb': 2}
print(a, b)  # aaa bbb

9 集合

9.1 集合相关注意点

s = set('abc')
print(s)  # {'b', 'a', 'c'}

9.2 集合方法

9.2.1 增加数据add，增加序列update

s = {1, 2, 3}
s.add(4)  # {2, 3, 1, 4}
s.add([1, 2])  # 报错

s = {1, 2, 3}
s.update([2, 4, 5])  # {3, 1, 4, 2, 5}
s.update(100)  # 报错

9.2.2 删除数据remove, discard, pop

# remove删除指定数据，数据不存在报错
# discard删除指定数据，数据不存在不报错
# pop随机删除某个数据，并返回这个数据

10 enumerate枚举

d = {'name': 'zhangsan', 'age': 22}
for i in enumerate(d):
    print(i)  
# (0, 'name')
# (1, 'age')
s = 'ab'
for i in enumerate(s, start=2):
    print(i)
# (2, 'a')
# (3, 'b')

11 推导式

11.1 列表推导式

list = [i for i in range(10)]
list = [i for i in range(10) if i % 2 == 0]
list = [(i, j) for i in range(1, 3) for j in range(3)]

11.2 字典推导式

dict = {i: i**2 for i in range(1, 5)}

list1 = ['name', 'age', 'sex']
list2 = ['wx', 88, '男']
dict = {list1[i]: list2[i] for i in range(len(list1))}

counts = {'zzc0': 3, 'zzc1': 4, 'zzc2': 5}
dict = {key: value for key, value in counts.items if value >= 4}

11.3 集合推导式

l = [1, 1, 2]
list = {i**2 for i in l} # {1, 4}

12 函数

12.1 多返回值（逗号隔开默认返回元组）

def test():
  return 10, 20  # 等同于 return (10, 20)
print(test())  # (10, 20)
a, b = test()
print(a, b)  # 10 20

12.2 关键字参数

def userInfo(name, age, gender):
  print(f'名字{name}，年龄{age}，性别{gender}')

# 位置参数必须写在关键字参数前面，关键字参数不分前后顺序
userInfo('zhangsan', age=111, gender='男')  # 正常输出
userInfo('zhangsan', gender='男', age=111)  # 正常输出
userInfo(age=111, gender='男', 'zhangsan')  # 报错

12.3 缺省参数

# 位置参数必须写在缺省参数前面
def userInfo(name, age, gender='男', pos='学生'):
  print(f'名字{name}，年龄{age}，性别{gender}')


userInfo('zhangsan', 111)  # 输出性别为男，职位为学生
userInfo('zhangsan', 111, '女')  # 输出性别为女，职位为学生
# 如果存在多个缺省参数，调用函数需使用关键字参数
userInfo('zhangsan', 111,pos='老师')  # 输出性别为男，职位为老师

12.4 不定长参数

12.4.1 元组参数

def sum(*args):
  print(args)

sum()  # ()
sum(1)  # (1,)
sum(1, 2, 3)  # (1, 2, 3)

12.4.2 字典参数

def user(**kwargs):
  print(kwargs)

user()  # {}
user(name='zhangsan', age=111)  # {'name': 'zhangsan', 'age': 111}
user(1, 2, 3)  # 报错

12.4.3 综合

def user(num, *args, **kwargs):
  print(num)
  print(args)
  print(kwargs)

user()  # 报错
user(1)  # 1 () {}
user(1, 2, 3)  # 1 (2, 3) {}
user(1, 2, 3, name='zhangsan', age=111)  # 1 (2, 3) {'name': 'zhangsan', 'age': 111}

12.4.4 拆包

def user(*args, **kwargs):
    print(args)
    print(kwargs)

a = [1, 2]
b = {'name': 'zhangsan', 'age': 111}
user(*a, **b)  # 等同于user(1, 2, name='zhangsan', age=111)，*a相当于把列表拆包，**b相当于把字典拆包
# 输出：
# (1, 2)
# {'name': 'zhangsan', 'age': 111}

13 变量存储

13.1 不可变类型和可变类型

• 可变类型：
  列表
  字典

• 不可变类型：
  数字类型
  字符串
  元组

13.2 不可变类型存储原理

13.2.1 赋值语句

a = 1
print(id(a))  # 10914368
b = a
print(id(b))  # 10914368
a = 2
print(id(a))  # 10914400
print(id(b))  # 10914368

13.2.2 函数参数

def test(num):
    print(f'函数中形参num内存地址为{id(num)}')  # 10914656

a = 10
test(a)
print(f'实参a内存地址为{id(a)}')  # 10914656

13.2.3 函数返回值

def test():
    result = 'hello'
    print(f'函数中返回值result内存地址为{id(result)}')  # 140419531493328
    return result

r = test()
print(f'r内存地址为{id(r)}')  # 140419531493328

13.3 可变类型存储原理

13.3.1 列表（调用方法修改列表不改变其内存地址，但重新赋值会改变内存地址）

a = [1, 2, 3]
print(id(a))  # 1826865435144
a.extend([3, 4])
print(id(a))  # 1826865435144
a += [3, 4]  # 底层其实是a.extend([3, 4])，不等同于a = a + [3, 4]
print(id(a))  # 1826865435144
a = a + [3, 4]
print(id(a))  # 3209297916296

13.3.2 字典（调用方法修改字典不改变其内存地址，但重新赋值会改变内存地址）

a = {'name': 'zhangsan', 'age': 18}
print(id(a))  # 1491903397464
a.clear()
print(id(a))  # 1491903397464
a = {}
print(id(a))  # 1491903402776

13.3.3 字典的key值必须为不可变类型

a = {}
a['name'] = 'zhangsan'
print(a)  # {'name': 'zhangsan'}
a[1] = 44
print(a)  # {'name': 'zhangsan', 1: 44}
a[(1,)] = 1
print(a)  # {'name': 'zhangsan', 1: 44, (1,): 1}
a[[1, 2]] = 1
print(a)  # 报错TypeError: unhashable type: 'list'
a[{'name': 'xxx'}] = 1
print(a)  # 报错TypeError: unhashable type: 'dict'

13.4 修改全局变量值

num = 10
def test():
    global num
    num = 99  # 不能写为 global num = 99
    print(num)  # 99

test()
print(num)  # 99

若全局变量为可变类型，则使用方法修改其值时可不用global声明(但若重新对其赋值修改内存地址需要声明global)：

num = [1, 2]
def test():
   num.append(3)
   print(num)

test()  # [1, 2, 3]
print(num)  # [1, 2, 3]

14 lambda匿名函数

14.1 无参数

fn =  lambda: 100
print(fn)  # 函数地址
print(fn())  # 100

14.2 一个参数

fn =  lambda a: a
print(fn(100))  # 100

14.3 默认参数

fn =  lambda a, b, c=300: a + b + c
print(fn(100, 200))  # 600

14.4 可变参数：*args

fn =  lambda *args: args
print(fn(1, 2, 3))  # (1, 2, 3)

14.5 可变参数：**kwargs

fn =  lambda **kwargs: kwargs
print(fn(name='zhangsan', age=20))  # {'name': 'zhangsan', age: 20}

14.6 带判断lambda

fn =  lambda a, b: a if a > b else b
print(fn(1, 2))  # 2

14.7 列表数据按字典key值排序

students = [
  {'name': 'zhangsan', age: 13},
  {'name': 'lisi', age: 22}
]
students.sort(key=lambda x: x[age], reverse=True)
print(students)
# [
#  {'name': 'lisi', age: 22},
#  {'name': 'zhangsan', age: 13}
# ]

15 高阶函数

15.1 基础

def add(a, b, f):
  return f(a) + f(b)

add(-1, 2, abs)  # 3
# 也可简写为：print((lambda a, b, f: f(a) + f(b))(-1, 2, abs))
# 注：lambda整体必须加括号才能执行
add(1.1, 1.6, round)  # 3

15.2 map函数

l = [1, 2, 3]
result = map(lambda x: x ** 2, l)
print(result)  # <map object at 0x000001EA9061F548>
print(list(result))  # [1, 4, 9]

15.3 reduce函数

import functools
l = [1, 2, 3]
result = functools.reduce(lambda x, y: x + y, l)
print(result)  # 6

15.4 filter函数

l = [1, 2, 3]
result = filter(lambda x: x >= 2, l)
print(result)  # <filter object at 0x00000165947BF548>
print(list(result))  # [2, 3]

16 文件操作

16.1 文件操作步骤

# 1 打开open
f = open('test.txt', 'w')
# 2 读写文件write或read
f.write('内容')
# 3 关闭close
f.close()

16.2 文件读取方法

• test.txt

aaaaa
bbbbb
ccccc

16.2.1 read

f = open('test.txt')
print(f.read())  # 输出所有内容
print(f.read(10))
# 输出内容如下(换行符也算一个字符)
# aaaaa
# bbbb
f.close()

16.2.2 readlines

f = open('test.txt')
print(f.readlines())  # ['aaaaa\n', 'bbbbb\n', 'ccccc']
f.close()

16.2.3 readline

f = open('test.txt')
print(f'第一行：{f.readline()}')
# 输出内容如下(注意换行符)
# 第一行：aaaaa
#
f.readline()
print(f'第三行：{f.readline()}')  # 第三行：ccccc
f.close()

16.3 访问模式特点

16.3.1 r模式（如果文件不存在，报错；不支持写入操作，表示只读）

f = open('test.txt', 'r')  # 同 f = open('test.txt')，若test.txt不存在，则报错
print(f.read())  # 输出文件中所有内容
f.write('内容')  # 报错，r模式不支持写入操作
f.close()

16.3.2 w模式（如果文件不存在，新建文件；执行写入，会覆盖原有内容；不支持读取操作，表示只写）

f = open('test.txt', 'w')  # 若test.txt不存在，则新建；若test.txt中有内容，执行完这部原文件内容会被清空
f.write('内容')  # 执行写入，会覆盖原有内容
print(f.read())  # 报错
f.close()

16.3.3 a模式（追加，如果文件不存在，新建文件；执行写入，在原有文件基础上追加新内容；不支持读取操作，表示只写）

f = open('test.txt', 'a')  # 若test.txt不存在，则新建；若test.txt中有内容，执行完这部原文件内容不变
f.write('内容')  # 执行写入，在原有文件基础上追加新内容
print(f.read())  # 报错
f.close()

16.3.4 r+模式（如果文件不存在，报错；支持写入操作）

f = open('test.txt', 'r+')  # 若test.txt不存在，则报错
f.write('内容')  # 不会报错
print(f.read())  # 输出文件中所有内容
f.close()

16.3.5 w+模式（如果文件不存在，新建文件；执行写入，会覆盖原有内容；支持读取操作）

f = open('test.txt', 'w+')  # 若test.txt不存在，则新建；若test.txt中有内容，执行完这部原文件内容会被清空
print(f.read())  # 输出为空，因为文件指针在最后，且文件中内容已被清空
f.write('内容')  # 执行写入，会覆盖原有内容
print(f.read())  # 输出为空，因为文件指针在最后
f.close()

16.3.6 a+模式（追加，如果文件不存在，新建文件；执行写入，在原有文件基础上追加新内容；支持读取操作）

f = open('test.txt', 'a+')  # 若test.txt不存在，则新建；若test.txt中有内容，执行完这部原文件内容不变
print(f.read())  # 输出为空，因为文件指针在最后
f.write('内容')  # 执行写入，在原有文件基础上追加新内容
print(f.read())  # 输出为空，因为文件指针在最后
f.close()

16.4 seek函数(设置文件指针位置)

文件对象.seek(偏移量, 起始位置)  # 偏移量为正整数；起始位置(不传入默认为0)：0(开头)，1(当前)，2(结尾)

f = open('test.txt', 'w+') 
print(f.read())  # 输出为空，因为文件中内容已被清空，且文件指针在最后
f.write('aaaaa')
print(f.read())  # 输出为空，因为文件指针在最后
f.seek(2, 0)
print(f.read())  # aaa
f.seek(1)  # 只传入一个参数代表偏移量为1，起始位置默认为0
print(f.read())  # aaaa
f.close()

16.5 大文件复制

file = open("test.txt")
file_copy = open("test[复件].txt", "w")
while True:
    txt = file.read(1024)  # txt = file.readline()
    if not txt:  # if len(txt) == 0:
        break
    file_copy.write(txt)
file.close()
file_copy.close()

17 系统OS模块

17.1 文件或文件夹重命名

import os
os.rename('1.txt', '2.txt')  # os.rename(旧文件(夹)名, 新文件(夹)名)

17.2 删除文件

import os
os.remove('1.txt')  # os.remove(要删除的文件名)

17.3 新建文件夹

import os
os.mkdir('test')  # os.mkdir(要新建的的文件夹名)

17.4 删除文件夹

import os
os.mkdir('test')  # os.rmdir(要删除的文件夹名)

17.5 获取当前所在目录

import os
print(os.getcwd())

17.6 改变当前所在目录

import os
print(os.chdir('C:\Program Files'))  # os.chdir(要进入的文件夹名(文件夹名绝对路径和相对路径均可))

17.7 获取目录列表

import os
print(os.listdir('../'))  # os.listdir(要访问的文件夹名(文件夹名绝对路径和相对路径均可))，返回列表，列表中元素为文件名和文件夹名的字符串

18 eval函数

eval()函数将字符串当成有效的表达式来求值并返回计算结果

print(eval("1 + (2 * 3)"))  # 7
print(eval("'*' * 3"))  # ***
print(type(eval("[1, 2, 3]")))  # <class 'list'>
print(type(eval("1,")))  # <class 'tuple'>