【python知识点总结】第一章 基础知识点
第一节 python基础
文章目录
- 第一节 python基础
-
- 一 基础
-
- 1、注释
- 二 数据类型和变量
-
- 1、运算符
-
- 1.1 算术运算符
- 1.2 赋值运算符
- 1.3 复合赋值运算符
- 1.4 比较运算符
- 1.5 逻辑运算符
- 2、常量和变量
- 3、输出换行
- 4、格式化输出
- 5、输入
- 6、数据类型
- 7、布尔类型
- 8、转换数据类型
- 三 字符串和编码
-
- 1、字符串四种形式
- 2、字符串操作方法
-
- 2.1 查找
- 2.2 修改
- 2.3 判断
- 2、ASCII—>Unicode—>UTF-8
- 四 使用list和tuple
-
- 1、列表list——[ ]
-
- 1.1 定义列表
- 1.2 查找列表元素（下标）
- 1.3 查找列表元素（函数） —— 见字符串板块讲解
- 1.4 插入列表元素
- 1.5 删除列表元素
- 1.6 修改列表元素
- 1.7 列表复制copy()
- 1.8 列表嵌套
- 1.9 判断数据是否存在
- 1.10 列表遍历
- 2、元组tuple——（ ）
-
- 2.1 定义元组
- 2.2 查找元组元素（下标）
- 2.3 查找元组元素（函数）
- 2.4 元组嵌套
- 五 条件判断
-
- 1、if...elif...else
- 2、三目运算符
- 六 循环
-
- 1、for ... in ...
- 2、while
- 3、break
- 4、continue
- 5、else
-
- 5.1 while...else:
- 5.2 for...else:
- 七 使用dict和set
-
- 1、字典dict——{ }
-
- 1.1 创建字典
- 1.2 增
- 1.3 删
- 1.4 改
- 1.5 查
- 1.6 字典遍历
-
- 1.6.1 遍历所有Key
- 1.6.2 遍历所有value
- 1.6.3 遍历字典的元素
- 2、集合set——（ ）
-
- 2.1 创建集合
- 2.2 增
- 2.3 删
- 2.4 查
- 2.5 集合的交集和并集
- 八 公共操作
-
- 1、运算符
- 2、公共方法
- 3、容器类型转换
- 九 推导式（生成式）
-
- 1、列表推导式
- 2、字典推导式
- 3、集合推导式
一 基础
1、注释
三类注释方法
# 注释1
'''
注释2
'''
"""
注释3
"""
二 数据类型和变量
1、运算符
1.1 算术运算符
*+ 加 - 减 * 乘 / 除 //整除 %取余 *指数 （）小括号
优先级：（）高于** 高于* / // %高于+ -
除有两种：/和//
print(10/3) # 结果为浮点数3.3333333333333335
print(10//3) # //结果为整数3
print(10%3) # /结果为整数1
加减乘则无差别
print(200+100)
print('1024 * 768 =',1024 * 768)
求平方/立方
a=2
answer1=a**2 # 4
answer2=a**3 # 8
1.2 赋值运算符
= 赋值
# 单个变量赋值
num=1
print(num)
# 多个变量赋值
num1,float1,str1=10,0.5,'hello'
print(num1) # 10
print(float1) # 0.5
print(str1) # hello
# 多变量赋相同的值
a=b=10
print(a) # 10
1.3 复合赋值运算符
先计算算术运算符，再将结果赋值到等号左边
+= ——>加法赋值运算符
-= ——>减法赋值运算符
*= ——>乘法赋值运算符
/= ——>除法赋值运算符
//= ——>整除赋值运算符
%= ——>取余赋值运算符
**= ——>幂赋值运算符
a=10
a+=1 #a=a+1
print(a) # 11
b=10
b+=2*3 # b+=6 先算右边的表达式，再算复合赋值
print(b) # 16
1.4 比较运算符
== 判断相等
!= 不等于
> 左大于右，则条件为真
< 左小于右，则条件为真
>= 左大于等于右，则条件为真
<= 左小于等于右，则条件为真
1.5 逻辑运算符
and 与，都真则真
or 或，都假则假
not 非，相反
a=0
b=1
c=2
print((ab)) # True
print((ab)) # True
print(not (c>b)) # False
print(a and b) # 0
print(b and c) # 2 —— and只要有一个值为0，结果都为0，否则为最后一个非0数字
print(a or b) # 1
print(a or c) # 2 —— or只有所有结果为0才为0，否则返回第一个非0数字
2、常量和变量
约定俗成，变量小写，常量大写，直接赋值
__xxx__在python中是特殊变量，__xxx或者_xxx变量和函数是非公开的，只有xxx才是公开的，可以直接引用，如abc, PI
**命名规范：**①由数字、字母、下划线组成 ②不能数字开头 ③不能使用内置关键字 ④严格区分大小写
**命名习惯：**①大驼峰:即每个单词首字母都大写，例如: MyName ②小驼峰:第二个(含)以后的单词首字母大写，例如: myName ③下划
线:例如:my_ name
PI=3.12234
AI=23
a=110_0 # _不影响，方便自己看几位数
b=1.123
my_name='chen'
hisName='Tom'
3、输出换行
print表示输出
# 直接输出变量
a=1
b='chloris'
print(a)
print('hello',b)
# 直接输出数字
print(123)
# 直接输出字符串
print('chen')
print("abc")
print('I\'m ok') # \为转义字符
# \n为换行；\t为制表符，4个空格距离
print('hello\nworld')
print('hello\tworld') # hello world
# ''' '''表示多行内容，可直接在内部换行，不用加连接符
print('''ds
sds
sd''')
print(r'\\\t\\') # r' ' 表示中间的字符不转义，直接输出
4、格式化输出
%d——>有符号的十进制整数
%f——>浮点数
%s——>字符串
%o——>八进制整数
%x——>十六进制整数（小写ox）
%c——>字符
%u——>无符号十进制整数
%e——>科学计数法
print('%.2f' % 3.1415) # 3.14 —— 小数点后保留两位小数
print('%0.2f',93.45323) # %0.2f 93.45323
print('%06d' % 23) # 000023 —— 表示输出的整数显示位数，不足的以0补全，超出的原样输出
print('hello,%s' % 'ww') # hello,ww
print('hello,%s','ww') # hello,%s ww
print('age:%d,gender:%d' % (20,True)) # age:20,gender:1
#f'{表达式}' —— f格式化，%s也可以式化
age=18
name='chen'
print('我的名字是%s,今年%d岁了' % (name,age))
print(f'我的名字是{name},今年{age}岁了')
print('我的名字是%s,今年%S岁了' % (name,age))
a='abc'
b=123
print('%c',a) # %c abc
print('%d' % b) # 123
python和 C的输出不太一样，不能用 , 一定要用 %，否则是输出全部内容
5、输入
input()表示输入，接收到用户输入后，存储到变量中，且将数据当作字符串
a=input('请输入：')
print(a)
6、数据类型
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EsB4waec-1673962650093)(E:\Temp\1673093353881.png)]
num=1
num1=1.1
num2='abc'
print(type(num)) #
print(type(num1)) #
print(type(num2)) #
a1=[10,20,30]
print(type(a1)) # 列表
a2=(10,20,30)
print(type(a2)) # 元组
a3={10,20,30}
print(type(a3)) # 集合
a4={'name':'Tom','age':19}
print(type(a4)) # 字典——键值对
7、布尔类型
print(9>8)
print(False)
print(True and False) # 所有都为true
print(True or False) # 只要一个为true
print(not False)
8、转换数据类型
int(x,[,base])——>将x转换为一个这个数
float(x)——>将x抓为一个浮点数
str(x)——>将对象x转为字符串
eval(str)——>用来计算在字符串中的有效Python表达式，并返回一个对象（该什么就什么）
tuple(s)——>将序列s转为一个元组
list(s)——>将序列s转为一个列表
a=input('请输入：') # 请输入：123
print(a) # 123
print(type(a)) #
b=int(a)
print(type(int(a))) #
print(type(b)) #
age=int(input('请输入年龄：')) # age转为int
str3='1'
str5='(1000,2000,30000)'
print(type(eval(str3))) #
print(type(eval(str5))) #
三 字符串和编码
1、字符串四种形式
str1='abc' # 单引号
str2="def" # 双引号
str3='''I'\m Tom'' # 三引号 —— \为转义符
str4="""k # 三双引号 —— 和三引号一样，内部换行输出时格式也会换行
lm"""
print(str2)
print(str4)
print(str1[2]) # c —— 用下标精确输出
2、字符串操作方法
2.1 查找
即查找子串在字符串中的位置或者出现的次数
find()：检测某个子串是否包含在这个字符串中，如果在则返回子串开始位置下标，不在返回-1；rfind()查找方向为从右侧开始
语法：字符串序列.find(子串，开始位置下标，结束位置下标)，开始和结束位置下标省略表示整个字符串序列中查找
index()：检测某个子串是否包含在这个字符串中，如果在则返回子串开始位置下标，否则报异常；rindex()查找方向为从右侧开始
语法：字符串序列.index(子串，开始位置下标，结束位置下标)
count()：返回某个子串在字符串中出现的次数
语法：字符串序列.count(子串，开始位置下标，结束位置下标)
str='hello world and my name is Tom'
print(str.find('my')) # 16
print(str.index('an',0,9)) # ValueError: substring not found
print(str.count('a')) # 2
2.2 修改
通过函数修改字符串中的数据
replace()：替换；有返回值，是修改后的新字符串，不会改变原有字符串
语法：字符串序列.replace(旧子串，新子串，替换次数)，替换次数不写表示全部替换
split()：分割；返回一个列表
语法：字符串序列.split(分割字符，num)，num表示分割字符出现的次数，将来返回数据个数为num+1个
join()：将列表中的字符串合并为一个大字符串
语法：字符或子串.join(多字符串组成的序列)
capitalize()：将字符串第一个字符转换成大写，其他字符全部变为小写；字符串序列.capitalize()
title()：将字符串每个单词首字母转换成大写；字符串序列.title()
lower()：将字符串中大写转小写；字符串序列.lower()
upper()：将字符串中小写转大写；字符串序列.upper()
str='hello world and my name is Tom and my home is China'
str1=str.replace('and','but')
print(str) # hello world and my name is Tom and my home is China
print(str1) # hello world but my name is Tom but my home is China
list1=str.split('and')
print(list1) # ['hello world ', ' my name is Tom ', ' my home is China'] —— 会丢失分割字符
list2=['aa','bb','cc','dd','ee']
str2='...'.join(list2)
print(str2) # aa...bb...cc...dd...ee
lstrip()：删除字符串左侧空白字符
rstrip()：删除字符串右侧空白字符
strip()：删除字符串两侧空白字符
str=' my name is Tom '
print(str.rstrip()) # my name is Tom
ljust()：左对齐，并使用指定字符填充对应长度的新字符串，字符串序列.ljust(长度，填充字符)，填充字符默认空格
rjust()：右对齐，并使用指定字符填充对应长度的新字符串
center()：居中对齐，并使用指定字符填充对应长度的新字符串
str='nihao'
print(str.center(11,'.'))
2.3 判断
判断真假，返回布尔类型
startswith()：检查字符串是否以指定子串开头
语法：字符串序列.startswith(子串，开始位置下标，结束位置下标)，不指定下标则表示查找整个字符串
endswith()：检查字符串是否以指定子串结尾
语法：字符串序列.endswith(子串，开始位置下标，结束位置下标)
isalpha()：字符串中至少有一个字符且所有字符都是字母则True
isdigit()：字符串中只包含数字则True
isalnum()：字符串中至少有一个字符且所有字符都是字母或数字则True
isspace()：字符串中只包含空白则True
str='nihao'
print(str.startswith('ni')) # True
str='nihao123'
print(str.isalpha()) # False
2、ASCII—>Unicode—>UTF-8
ASCII码一字节，Unicode两个字节，UTF-8一至六个可变长字节
print(ord('A')) # 获取字符的整数表示ord()——65
print(chr(66)) # 将编码转为对应的字符chr()——B
print(len('acf')) # 计算str中包含多少字符用len()——3
四 使用list和tuple
1、列表list——[ ]
list是列表，可随时添加与删除，一次性存储多个数据且可以为不同类型，列表中的数据允许更改
1.1 定义列表
name=['mack','joy','amy']
输出列表
print(name)
计算列表长度
print(len(name)) # 3
1.2 查找列表元素（下标）
print(name[2]) # 提取第三个元素——amy
print(name[-1]) # 提取倒数第一个元素——amy
print(name[0]) # 提取第一个元素——mack
print(name[-3]) # 提取倒数第三个元素——mack
1.3 查找列表元素（函数） —— 见字符串板块讲解
index()：返回指定数据所在位置下标
count()：统计指定数据在当前列表出现的次数
len()：访问列表长度，即列表中数据的个数
list=['Tom','Lili','Lucu','Jack']
print(list.index('Tom')) # 0
print(list.count('Jack')) # 1
print(len(list)) # 4
1.4 插入列表元素
append()：列表序列.append(数据)
extend()：列表序列.extend(数据)
insert()：列表序列.insert(位置下标，数据)
name.append('bob') # 插入到表尾——append不用指定位置，直接表尾
print(name) # ['mack', 'joy', 'amy', 'bob']
name.append([1,2]) # append插入序列
print(name) # ['mack', 'joy', 'amy', [1, 2]]
name.extend('Ali') # extend插入序列——将数据拆开追加到列表
print(name) # ['mack', 'joy', 'amy', 'A', 'l', 'i']
name.extend([1,2])
print(name) # ['mack', 'joy', 'amy', 1, 2]
name.insert(1,'davi') # 插入到第一个元素后——insert需要指定位置
print(name) # ['mack', 'davi', 'joy', 'amy', 'bob']
1.5 删除列表元素
del()：del 目标
pop()：删除指定下标，默认最后一个；可以返回删除的数据；列表序列.pop(下标)
remove()：删除列表这第一个匹配项；列表序列.remove(数据)
clear()：清空列表
del name
print(name) # name 'name' is not defined
del name[1]
print(name) # ['mack', 'joy', 'amy']
name.pop() # 不指定下标删除末尾元素
print(name) # ['mack', 'davi', 'joy', 'amy']
name1=name.pop(2) # 删除第3个位置的元素，同时可以返回被删除的元素
print(name) # ['mack', 'davi', 'amy']
print(name1) # joy
name.remove('joy')
print(name) # ['mack', 'davi', 'amy']
name.clear()
print(name) # []
1.6 修改列表元素
修改指定下标的数据
name[0]='michel' # 替换第一个元素
print(name) # ['michel', 'davi', 'amy']
name[1]=20 # 可以替换不同类型
print(name) # ['michel', 20, 'amy']
列表排序 sort()
列表序列.sort(key=None,reverse=False)
L=[2,5,1,3,7]
L.sort() # 默认reverse=False升序排序
print(L) # [1, 2, 3, 5, 7]
L.sort(reverse=True) # reverse=True降序排序
print(L) # [7, 5, 3, 2, 1]
列表逆序 reverse()
L=[2,5,1,3,7]
L.reverse()
print(L) # [7, 3, 1, 5, 2]
1.7 列表复制copy()
name=['mack','joy','amy']
name1=name.copy()
print(name1)
1.8 列表嵌套
即一个列表里包含了其他的子列表
student=['a',['b'],['boy','girl'],'c']
print(student) # ['a', ['b'], ['boy', 'girl'], 'c']
print(len(student)) # 输出列表长度——4
print(student[2][0]) # 按照二元数组位置进行输出——boy
student[1].append('h') # 插入元素，要指定第几个列表
print(student) # ['a', ['b', 'h'], ['boy', 'girl'], 'c']
1.9 判断数据是否存在
in：判断指定数据是否在某个列表序列中，在则True
not in：是否不在序列中
list=['Tom','Lili','Lucu','Jack']
print('Tom' in list) # True
print('Sum' not in list) # True
1.10 列表遍历
# while循环
name=['mack','joy','amy']
i=0
while i2、元组tuple——（ ）
tuple是元组，可以存储多个数据，一旦初始化后不能修改
2.1 定义元组
# 多个元组数据
hobby=('basketball','tennis','football')
# 单个元组数据
sex=(1,) # 元组中只有一个元素时必须加，与小括号进行区别
print(sex) # 输出也会区别——(1,)
2.2 查找元组元素（下标）
t1=('aa','bb','cc','dd')
print(t1[2])
2.3 查找元组元素（函数）
index()：查找某个数据，若存在则返回对应的下标，否则报错
count()：统计某个数据在元组中出现的个数
len()：统计元组中数据个数
t1=('aa','bb','cc','dd')
print(t1.index('bb'))
print(t1.count('cc'))
print(len(t1))
2.4 元组嵌套
t=('a','b',['A','B'])
t[2][0]='X' # 内嵌列表可以更改值，因为元组指向的列表不变
print(t) # ('a', 'b', ['X', 'B'])
五 条件判断
1、if…elif…else
s=input('age=') # input输入是字符串
age=int(s) # 转换为整数
if 0<=age<=6:
print('kid')
elif age>=18:
print('adult')
else:
print('teenager')
2、三目运算符
条件成立执行的表达式 if 条件 else 条件不成立执行的表达式
a=2
b=2
c=a if a>b else b
print(c) # 2
六 循环
1、for … in …
for (临时变量) in (序列)：
代码1
直接作用于for循环的数据类型：
（一）集合数据类型：list、tuple、dict、set、str
（二）generator：生成器和带yield的generator function
迭代输出列表的元素
name=['mack','joy','amy']
for a in name:
print(a) # mack joy amy
迭代计算范围内的值
sum=0
for x in [1,2,3,4,5,6]: # 直接写成数组形式表示x在1-6之间
sum+=x
print(sum) # 21
sum=0
for y in range(101): # 数值太多时用range生成整数序列
sum+=y
print(sum) # 5050
number=list(range(10)) # 转为列表输出
for numbers in number:
print(numbers)
2、while
表示方法与c一样
sum=0
n=99
while n>0:
sum+=n
n=n-2
print(sum) # 2500
# 九九乘法表，while嵌套
i=1
while i<10:
j=1
while j<=i:
print(f'{i}*{j}={i*j}',end='\t') # print结束符可以更改
j+=1
print() # 空的print只换行
i+=1
3、break
n=1
while n<=100:
if n>10:
break # 退出循环
print(n) # 1 2 3 4 5 6 7 8 9 10
n+=1
print('END')
4、continue
n=0
while n<10:
n=n+1
if n%2==0:
continue # 跳过本次循环
print(n) # 1 3 5 7 9
print('END')
continue表示跳过本次循环，即它下面的代码都不执行，若没有改变变量值的代码很容易造成死循环，
必须在continue之前修改计数器
5、else
当循环正常结束后要执行的代码放else中，非正常情况不执行
5.1 while…else:
# 循环正常结束时
i=1
while i<5:
print("你好")
i+=1
else:
print("早上好") # 你好 你好 你好 你好 你好 早上好
# break 结束
i=1
while i<5:
print("你好")
if 3==i:
break
i+=1
else:
print("早上好") # 你好 你好 你好 —— 不会执行else
# continue 结束
i=1
while i<5:
print("你好")
if 3==i:
i+=1
continue
i+=1
else:
print("早上好") # 你好 你好 你好 你好 早上好 —— 会执行else
5.2 for…else:
# 循环正常结束
str1='itheima'
for i in str1:
print(i)
else:
print('正常结束') # i t h e i m a 正常结束
# break 结束
str1='itheima'
for i in str1:
if 'e'==i:
break
print(i)
else:
print('正常结束') # i t h
# continue 结束
str1='itheima'
for i in str1:
if 'e'==i:
continue
print(i)
else:
print('正常结束') # i t h i m a 正常结束
七 使用dict和set
1、字典dict——{ }
dict即dictionary或map，用键—值存储，是可变类型
dict的key是不可变对象，即可以用字符串、整数作为key，但是不能用list，不支持下标查找，按键名查找
1.1 创建字典
d={'Mich':95,'Bob':75,'Tracy':85}
print(d) # {'Mich': 95, 'Bob': 75, 'Tracy': 85}
# 创建空字典
dict={} # 直接创建
dict1=dict() # 利用dict函数创建
打印对应值
print(d['Mich']) # 95
1.2 增
字典序列[key]=值，若key存在则修改值，若不存在则新增
d={'Mich':95,'Bob':75,'Tracy':85}
d['Tom']=56
print(d) # {'Mich': 95, 'Bob': 75, 'Tracy': 85, 'Tom': 56}
d['Bob']=100
print(d) # {'Mich': 95, 'Bob': 100, 'Tracy': 85}
1.3 删
del：删除字典或者字典中指定的键值对
pop()：清除指定键值对
clear()：清空字典
d={'Mich':95,'Bob':75,'Tracy':85}
d.pop('Bob')
print(d) # {'Mich': 95, 'Tracy': 85}
del d['Bob']
print(d) # {'Mich': 95, 'Tracy': 85}
d.clear()
print(d) # {}
del(d)
1.4 改
字典序列[key]=值，与增的操作一样
d={'Mich':95,'Bob':75,'Tracy':85}
d['Bob']=100
print(d) # {'Mich': 95, 'Bob': 100, 'Tracy': 85}
1.5 查
key值查找，若存在则返回对应的值，否则报错
get()：字典序列.get(key,默认值)，key不存在则返回默认值，默认None
keys()：查找字典中所有的key，返回可迭代对象(可for遍历)
values()：查找字典中所有的value，返回可迭代对象(可for遍历)
items()：查找字典中所有键值对，返回可迭代对象(可for遍历)，里面的数据是元组
in：判断key是否在字典中，返回布尔类型
d={'Mich':95,'Bob':75,'Tracy':85}
print(d['Mich']) # 95
print('Boo' in d) # 通过in直接判断——False
print(d.get('boo')) # 通过get方法判断——默认返回None
print(d.get('boo',-1)) # 设置不存在时返回值-1
print(d.keys()) # dict_keys(['Mich', 'Bob', 'Tracy'])
print(d.values()) # dict_values([95, 75, 85])
1.6 字典遍历
1.6.1 遍历所有Key
d={'Mich':95,'Bob':75,'Tracy':85}
for i in d.keys():
print(i) # Mich Bob Tracy
1.6.2 遍历所有value
d={'Mich':95,'Bob':75,'Tracy':85}
for i in d.values():
print(i) # 95 75 85
1.6.3 遍历字典的元素
d={'Mich':95,'Bob':75,'Tracy':85}
for i in d.items():
print(i) # ('Mich', 95) ('Bob', 75) ('Tracy', 85)
#将key和value拆包
d={'Mich':95,'Bob':75,'Tracy':85}
for key,value in d.items():
print(f'{key}={value}') # Mich=95 Bob=75 Tracy=85
2、集合set——（ ）
set只有key，没有value，key不能重复
集合中数据没有顺序，不支持下标操作，是可变类型
2.1 创建集合
用{}或者set()，空集合创建只能set()
s=set([4,2,3])
print(s) # {2, 3, 4}
s2={10,20,30}
print(s2) # {10，20，30}
s2={10,20,30,40,50}
print(s2) # {40, 10, 50, 20, 30} —— 没有顺序
s1=set([1,1,2,2,2,3])
print(s1) # 有重复的key不会多显示 —— {1, 2, 3}
s2={10,20,30,10,30}
print(s2) # {10，20，30}
s2=set('abcde')
print(s2) # {'a', 'e', 'd', 'b', 'c'} —— 会分割成单独字符
#创建空集合
s2=set()
print(s2) # set()
2.2 增
add()：增加单个数据
update()：追加的数据是序列
s=set([4,2,3])
s.add(5) # 若key重复，则添加不成功
print(s) # {2, 3, 4, 5}
s2={10,20,30,10,30}
s2.update([100,200])
print(s2) # {100, 200, 10, 20, 30}
2.3 删
remove()：删除集合中指定的数据，如果数据不存在报错
discard()：删除集合中指定的数据，如果数据不存在不报错
pop()：随机删除集合中某个数据，并返回这个数据
s={4,2,3,5}
s.remove(2)
print(s) # {3, 4, 5}
s.discard(4)
print(s) # {2, 3, 5}
del_num=s.pop()
print(del_num) # 2
print(s) # {3, 4, 5}
2.4 查
in/not in
s=set([4,2,3,5])
print(10 in s) # False
2.5 集合的交集和并集
s=set([4,2,3])
s1=set([1,1,2,2,2,3])
print(s&s1) # {3}
print(s|s1) # {1, 2, 3, 4, 5}
八 公共操作
1、运算符
| 运算符 | 描述 | 支持的容器类型 |
|---|---|---|
| + | 合并 | 字符串、列表、元组 |
| * | 复制 | 字符串、列表、元组 |
| in | 元素是否存在 | 字符串、列表、元组、字典 |
| not in | 元素是否不存在 | 字符串、列表、元组、字典 |
str1='aa'
str2='bb'
list1=[1,2,3]
list2=[10,20,30]
t1=(1,2)
t2=(10,20)
dict1={'name':'python'}
dict2={'age':20}
# 合并+
print(str1+str2) # aabb
print(list1+list2) # [1, 2, 3, 10, 20, 30]
print(t1+t2) # (1, 2, 10, 20)
# 复制*
print(str1*2) # aaaa
print(list1*1) # [1, 2, 3]
print(t1*4) # (1, 2, 1, 2, 1, 2, 1, 2)
print('-'*10) # ----------
# 存在
print('10' in str1) # False
print(1 in list1) # True
print(20 not in t1) # True
print('name' not in dict1) # False
print('name' in dict1.keys()) # True
print('name' in dict1.values()) # False
2、公共方法
len()：计算容器中元素个数
del/del()：删除
max()：返回容器中最大值
min()：返回容器中最小值
range(start,end,step)：生成从start到end的数字，步长为step，供for循环使用；不包含end位，step默认1，默认从0开始
enumerate()：将一个可遍历的数据对象（列表、元组、字符串）组合为一个索引序列，同时列出数据和数据下标，用于for循环；
enumerate(可遍历对象,start=0)，start设置遍历数据下标的起始值，默认0
str1='abcdefg'
list1=[1,2,3,4]
t1=(1,2)
s1={10,20,30,40,50,60}
dict1={'name':'python','age':20}
# len
print(len(str1)) # 7
print(len(list1)) # 4
print(len(t1)) # 2
print(len(s1)) # 6
print(len(dict1)) # 2
# del
del str1
del list1
del(list1[2])
print(list1) # [1, 2, 4]
del dict1
del(dict1['name'])
print(dict1) # {'age': 20}
# max/min
print(max(str1)) # g
print(min(list1)) # 1
# range
for i in range(1,10,2):
print(i) # 1 3 5 7 9
for j in range(4):
print(j) # 0 1 2 3
# enumerate
list1=['a','b','c','d']
for i in enumerate(list1):
print(i) # (0, 'a') (1, 'b') (2, 'c') (3, 'd')
for i in enumerate(list1,start=2):
print(i) # (2, 'a') (3, 'b') (4, 'c') (5, 'd')
3、容器类型转换
tuple()：将某个序列转为元组
list()：将某个序列转为列表
set()：将某个序列转为集合
list1=['a','b','c','d']
s1={10,20,30,40,50}
t1=(1,2,3)
print(tuple(list1))
九 推导式（生成式）
即化简代码量
1、列表推导式
作用：用一个表达式创建一个有规律的列表或控制一个有规律的列表；[xx for xx in range()]
# 创建1-10的列表——for方法
list=[]
for i in range(1,11):
list.append(i)
print(list) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# while方法
list1=[]
i=1
while i<11:
list1.append(i)
i+=1
print(list1) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 列表推导式
list2=[i for i in range(1,11)] # for左边的i为返回值，[]表示接收数据为列表，推导式中for循环代码相同
print(list2) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 在列表推导式中加条件判断if
list3=[i for i in range(1,11) if i%2==0] # if也是直接抄进去
print(list3) # [2, 4, 6, 8, 10]
# 多个for循环列表推导式
list4=[(i,j) for i in range(1,3) for j in range(3)]
print(list4) # [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
2、字典推导式
作用：快速合并列表为字典或提取字典中目标数据；{xx1:xx2 for … in …}
# 创建一个字典，key为1-5数字，values为key的平方
# for方法
dict1={}
for i in range(1,6):
dict1[i]=i**2
print(dict1) # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
# 字典推导式
dict2={i:i**2 for i in range(1,6)} # 字典即{}，返回值为k:v
print(dict2) # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
# 将两个列表合并为一个字典
list1=['name','age','gender']
list2=['Tom',20,'man']
dict1={list1[i]:list2[i] for i in range(len(list1))} # 两个列表数据个数相同，len(都可以)，但若不同，则统计个数少的
print(dict1) # {'name': 'Tom', 'age': 20, 'gender': 'man'}
# 提取字典中目标数据
dict1={'Mich':95,'Bob':75,'Tracy':85}
count1={key:value for key,value in dict1.items() if value>=80} # items获取所有数据并判断数据
print(count1) # {'Mich': 95, 'Tracy': 85}
3、集合推导式
{xx for xx in …}
# 创建集合为列表的2次方
list1=[1,1,2]
set1={i**2 for i in list1}
print(set1) # {1, 4} —— 集合去重功能
本文根据廖雪峰老师python课程和黑马程序员python课程进行记录