按老师要求总算在开学前给python最基础的部分过了一遍,

把一些刚学可能遗忘的知识点记录粘贴于此,便于日后回忆ctrl+f

Python数据类型:

​ Number、String、Tuple:不可变数据

​ List、Set、Dictionary:可变数据

​ 序列:string、list、tuple

基本语法:

​ 多语句一行用 ; 连接

​ 跨越多行:\ 续行符(在行尾时),’’’或者”””

选择、循环语句:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#选择语句:
if 表达式1:
#...
elif 表达式2:
#...
else:
#...

#循环语句:(没有do while)
while 表达式1:
#...
else: #当表达式1为false时执行
#...

for var in seq:
#...
else: #循环正常结束时执行
#...

####若break跳出循环则不执行else语句

Python推导式:

1
2
#先for后if,if过滤
a = {x for x in 'abracadabra' if x not in 'abc'}
1
2
3
#先if后for,对于元素的不同情况取不同值
list1 = ['python', 'test1', 'test2']
list2 = [word.title() if word.startswith('p') else word.upper() for word in list1]
1
2
3
4
5
6
7
8
9
10
vec1 = [2, 4, 6]
vec2 = [4, 3, -9]

#双重循环
vec3 = [x*y for x in vec1 for y in vec2]
#vec3 = [8, 6, -18, 16, 12, -36, 24, 18, -54]

#遍历
vec3 = [vec1[i]*vec2[i] for i in range(len(vec1))]
#vec3 = [8, 12, -54]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#嵌套列表
matrix = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
]
#### method1
[[row[i] for row in matrix] for i in range(4)]
#[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

#### method2
res = []
for i in range(4):
res.append([row[i] for row in matrix])

#### method3
res = []
for i in range(4):
nw = []
for row in matrix:
nw.append(row[i])
res.append(nw)

运算符:

​ **表示乘方,//表示整除

​ :=用于同时赋值且表达式有值的情况

1
2
if (n := len(a)) > 10:
print("length is longer than 10")

​ 逻辑运算符:not、and、or

​ 成员运算符:in、not in

​ 身份运算符:is、is not判断引用对象是否为同一个

基本数据类型

Number类型:

​ 删除引用:del var1

​ 科学计数法1e5类型为float

​ math模块:三角函数、sqrt、pow、ceil、floor、log等函数

1
2
import math
print(math.pow(x,y))

​ random模块:seed、random函数

​ max、min多参数

Str类型:

​ +(连接)、*(重复)、[]切片、in、r原义等

格式化输出output:
1
2
3
4
5
6
7
8
9
"我叫 %s 今年 %d 岁!" % ('小明', 10)
#%5.3f表示占5格保留3位小数

name = 'cz' ; age = 19
f'我叫 {name} 今年 {age} 岁!'

'{0}网址: "{site}!"'.format('菜鸟教程', site = 'www.runoob.com'))
#{}里加:5d表示占5格,:5f表示保留五位小数
#:10.5表示占10格5位有效数字,:10.5f占10格5位小数
capitalize() 将字符串的第一个字符转换为大写
count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数,如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
endswith(suffix, beg=0, end=len(string)) 检查字符串是否以 obj 结束,如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束,如果是,返回 True,否则返回 False.
find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中,如果指定范围 beg 和 end ,则检查是否包含在指定范围内,如果包含返回开始的索引值,否则返回-1
index(str, beg=0, end=len(string)) 跟find()方法一样,只不过如果str不在字符串中会报一个异常。
isalnum() 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False
isalpha() 如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False
isdigit() 如果字符串只包含数字则返回 True 否则返回 False..
islower() 如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True,否则返回 False
isnumeric() 如果字符串中只包含数字字符,则返回 True,否则返回 False
isspace() 如果字符串中只包含空白,则返回 True,否则返回 False.
istitle() 如果字符串是标题化的(见 title())则返回 True,否则返回 False
isupper() 如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True,否则返回 False
join(seq) 以指定字符串作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
len(string) 返回字符串长度
lower() 转换字符串中所有大写字符为小写.
max(str) 返回字符串 str 中最大的字母。
min(str) 返回字符串 str 中最小的字母。
replace(old, new , max) 把 将字符串中的 old 替换成 new,如果 max 指定,则替换不超过 max 次。
rstrip() 删除字符串末尾的空格或指定字符。
split(sep=””, maxsplit=string.count(str)) 以 sep 为分隔符截取字符串,如果 maxsplit 有指定值(默认为-1),则仅截取其+1 个子字符串,分隔后类型为list
splitlines(keepends) 按照行(‘\r’, ‘\r\n’, \n’)分隔,返回一个包含各行作为元素的列表,如果参数 keepends 为 False,不包含换行符,如果为 True,则保留换行符。
startswith(substr, beg=0,end=len(string)) 检查字符串是否是以指定子字符串 substr 开头,是则返回 True,否则返回 False。如果beg 和 end 指定值,则在指定范围内检查。
strip(chars) 在字符串上执行 lstrip()和 rstrip()
swapcase() 将字符串中大写转换为小写,小写转换为大写
title() 返回”标题化”的字符串,就是说所有单词都是以大写开始,其余字母均为小写(见 istitle())
upper() 转换字符串中的小写字母为大写
str.rjust(width[, fillchar]) 右对齐,设置宽度

List类型:

​ 删除列表元素 del list[1]

​ list / str都可以切片:lis[0 : -1 : 2],第一位起点,第二位终点 (不包含),-1、-2…表示从后往前索引,第三位表示step

​ lis[-1::-1] 可将原列表倒序

List遍历:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
####enumerate()函数同时得到索引位置和对应值
for i, v in enumerate(['tic', 'tac']):
print(i, v)
#0 tic
#1 tac

####同时遍历两个或更多的序列,可以使用 zip() 组合:
questions = ['name', 'favorite color']
answers = ['lancelot', 'blue']
for q, a in zip(questions, answers):
print('What is your {0}? It is {1}.'.format(q, a))
#What is your name? It is lancelot.
#What is your favorite color? It is blue.

####反向遍历序列
for i in reversed(lis)

####用for循环遍历可切片序列时利用切片确定遍历范围
for i in data[1:]:
#...
list.append(obj) 在列表末尾添加新的对象
list.count(obj) 统计某个元素在列表中出现的次数
list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值,可不同类型
list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj) 将对象插入列表
list.pop(index=-1) 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
list.remove(obj) 移除列表中某个值的第一个匹配项
list.reverse() 反向列表中元素
list.sort( key=None, reverse=False) 对原列表进行排序
list.clear() 清空列表
list.copy() 复制列表,类似lis[:]

Tuple类型:

​ 元组可以输出部分和连接 (+)、切片,但不能修改元素值

​ 字符串可以看成特殊的元组

​ 一个元素的元组要添加逗号

​ 多个变量用逗号隔开默认为元组类型

Dict类型:

​ 用 {} 、dict() 创建空字典

​ del 键值,删除字典元素

​ 字典的键值不能是可变数据

字典dict的创建方法:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#字典推导式创建字典:
{x: x**2 for x in (2, 4, 6)}
#{2: 4, 4: 16, 6: 36}

#直接键赋值增加条目

#关键字参数指定键值创建字典(关键字只为字符串时):
dict(sape=4139, guido=4127, jack=4098)
#{'sape': 4139, 'jack': 4098, 'guido': 4127}

#键值对元组列表:
dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
#{'sape': 4139, 'jack': 4098, 'guido': 4127}

#zip函数
dict(zip(['one', 'two', 'three'], [1, 2, 3]))
#{'three': 3, 'two': 2, 'one': 1}
字典dict的遍历:
1
2
3
4
5
knights = {'gallahad': 'the pure', 'robin': 'the brave'}
for k, v in knights.items():
print(k, v)
#gallahad the pure
#robin the brave
dict.clear() 删除字典内所有元素
dict.copy() 返回一个字典的浅复制
dict.fromkeys(seq, val) 创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值
dict.get(key, default=None) 返回指定键的值,如果键不在字典中返回 default 设置的默认值
key in dict 如果键在字典dict里返回true,否则返回false
dict.items() 返回一个视图对象
dict.keys() 返回一个视图对象
dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default,并且返回default
dict.update(dict2) 把字典dict2的键/值对更新到dict里,无返回值
dict.values() 返回一个视图对象
pop(key,default) 删除字典中键 key所对应的值,返回被删除的值,当键 key 不存在时返回default 的值
popitem() 返回并删除字典中的最后一对键和值,无返回值

​ dict.items() 单独取出一个时类型为tuple

Set类型:

​ 创建空集合要用 set() 不能用 {}

集合set运算符:
1
2
3
4
5
a - b  # 集合a中包含而集合b中不包含的元素
# {"apple", "banana", "cherry"} - {"google", "apple"} = {'banana', 'cherry'}
a | b # 集合a或b中包含的所有元素
a & b # 集合a和b中都包含了的元素
a ^ b # 不同时包含于a和b的元素
方法 描述
add() 为集合添加元素
clear() 移除集合中的所有元素
copy() 拷贝一个集合
discard() 删除集合中指定的元素,不存在不会报错
isdisjoint() 判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False。
x.issubset(y) 判断指定 x 集合是否为参数集合 y 的子集。
x.issuperset(y) 判断参数集合 y 是否为集合 x 的子集
pop() 随机移除元素
remove() 移除指定元素,元素不存在会报错
symmetric_difference() 返回两个集合组成的新集合,但会移除两个集合的重复元素:
update(seq) 给集合添加元素,参数可以是list、tuple等,可以多个

迭代器、生成器:

​ 字符串,列表或元组对象都可用于创建迭代器:使用 next() 和 iter() 函数

​ 迭代器对象可以用常规 for 语句遍历

函数Func:

1
2
def func(x):
return x**2

​ 函数参数为可变对象和不可变对象时实现不同:

​ 1、变量无类型,变量只是对象的引用(指针),指向的具体对象有类型

​ 2、不可变对象:对象在分配了地址后不可在地址上对对象的具体值进行修改

​ 3、可变对象:可以在地址上修改对象的具体值

​ 4、函数参数默认为形参,但是形参与实参相当于指向同一地址的指针

​ 5、若参数为可变对象,且函数中修改了形参所指向地址的值,则也会对实参造成影响,其他情况下函数对实参没有影响

​ 无返回值的函数或只写了return的函数返回值默认为 None

​ 函数内可以访问全局变量,但不能修改其值!用 global 引用以更新变量值

关键字参数:
1
2
3
4
5
#使用关键字参数允许函数调用时参数的顺序与声明时不一致,因为 Python 解释器能够用参数名匹配参数值。
def printi(name, age):
print ("名字: ", name)
print ("年龄: ", age)
printi(age = 50, name = "runoob")
默认参数:
1
2
3
4
5
6
def printi(name, age = 35): #若age没有传递参数则会使用默认参数
print ("名字: ", name)
print ("年龄: ", age)
printi(age = 50, name = "runoob")
print ("------------------------")
printi(name = "runoob")

!!!默认参数只能放在参数最后面

不定长参数:

​ 加了星号 ***** 的参数会以元组(tuple)的形式导入,存放所有未命名的变量参数。

​ 如果在函数调用时加 ***** 参数没有指定,它就是一个空元组。

1
2
3
4
5
6
7
def fp(arg1, *var): # **var则以字典形式导入
print (arg1)
print (var)
fp(70, 60, 50)
#输出:-----------------------
70
(60, 50)

​ 加了两个星号 ** 的参数会以字典的形式导入。

1
fp(1, a=2, b=3) #字典形式导入的函数,调用以'键=值' 的形式

​ 声明函数时,如果单独出现 *****,则 ***** 后的参数必须用关键字传入:

​ 声明函数时,如果单独出现 **/**,则 / 前的参数必须指定位置传入:

1
2
3
def f(a, b, /, c, d, *, e, f):
#...
f(10, 20, 30, d=40, f=60, e=50)
匿名函数lambda:
1
2
3
4
5
6
7
8
sum = lambda arg1, arg2 : arg1 + arg2
'''相当于:
def f(arg1, arg2):
return arg1 + arg2
sum = f
'''
#调用:
print(sum(10, 20))

​ 将匿名函数封装在另一个函数中,通过传入不同参数得到不同的匿名函数:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def myfunc(n):
return lambda a : a * n
mydoubler = myfunc(2)
mytripler = myfunc(3)

print(mydoubler(11))
print(mytripler(11))
#输出:---------------
22
33
'''
相当于:
mydoubler = lambda a: a * 2
mytripler = lambda a: a * 3
'''

内置函数:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
eval(str) #函数用来执行一个字符串表达式,并返回表达式的值。

enumerate(seq) #函数用于seq,列出数据和数据下标

filter(function, seq) #返回迭代器对象,序列的每个元素作为参数传递给函数进行判断,将返回 True 的元素放到可迭代对象

'{0} {1}'.format() #格式化函数

all(seq) any(seq) #all() 函数判断给定的iter中的所有元素是否都为TRUE,any() 函数判断是否至少有一个TRUE

input() #函数输入默认为str类型

len() #返回对象长度

max() min() sum() #序列为参数

map(function, seq) #根据提供的函数对指定序列做映射,以参数序列中每一个元素调用 function 函数,返回包含每次 function 函数返回值的可迭代对象

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
#sep间隔,默认空格; end默认换行;

range(start, stop, step) #左闭右开,返回可迭代对象

zip() #将序列中对应位置的元素打包成元组,返回迭代器对象,zip(*可迭代元组对象可以解压)

round(num[, pos]) #将num保留至第pos位小数(就近)

reversed(seq) #返回反转的迭代器

sorted(seq, key = None, reverse = False) #接收任何iter,reverse选择是否降序,key是一个函数(匿名函数),一般对原元素进行某种操作

模块:

1
2
3
4
5
import random
random.seed() #初始化随机数生成器
random.random() #[0, 1.0)
random.randrange(start, stop, step)
random.randint(a, b) #a<=N<=b

本文采用CC-BY-SA-3.0协议,转载请注明出处
Author: Evanq