一、用户交互
用户交互:输入 输出
1.1 输入
input()
、input(字符串的提示)
当程序执行到这里,就会暂停,等待我们输入数据给电脑;会有一个结果,打印出来,用变量接受,因为输入数据后面需要用到,且得到的结果永远是字符串类型
1.2 输出
计算机将信息给你 —> 打印 —> print() 打印出来
print(值, 值, 值)
print(end = '\n')
end以什么结尾,默认是换行print(值, 值, 值, sep = '')
sep=‘’ 当打印多个时,以什么作为间隔,默认是空格
print(1,end = '我是哒哒')
print(666)
#结果:1我是哒哒666
格式化输出:
-
why?
我们经常会输出具有某种固定格式的内容,比如:'亲爱的xxx你好!你xxx月的话费是xxx,余额是xxx‘,我们需要做的就是将xxx替换为具体的内容 -
what / when ?
把一段字符串里面的某些内容替换掉之后再输出,就是格式化输出。即需要输出的字符串中包含了变量时使用。 -
how?
①f'字符{变量名}'
变量的数据不限 (⭐推荐)a = 18 b = [1,2,3] print(f'我的年龄是{a},{b}') # 结果:我的年龄是18,[1,2,3]
②
format()
方法print('我的年龄是{},{}'.format(a,b)) print('我的年龄是{1},{0}'.format(a,b)) 结果: # 我的年龄是18[1,2,3] # 我的年龄是[1,2,3]18
③
%
print('我的名字是%s,年龄是%s,'%('哒哒','18')) # 结果:我的名字是哒哒,年龄是18
二、运算符
算术运算符 | 描述 | 示例(x=9,y=2) |
---|---|---|
+ | 加,两个对象相加 | x+y得11 |
- | 减,两个对象相减 | y-x得-7 |
* | 乘,两个对象相乘 | x*y得18 |
/ | 除,相除后得到的返回值会保留整数与小数部分 | x/y得4.5 |
// | 取整除,相除后得到的返回值只保留整数部分 | x//y得4 |
% | 取余,相除后只返回余数 | x%y得1 |
** | 幂,取一个数的n次方 | x**y得81 |
比较运算符 | 说明(结果都是True或False) |
---|---|
> | 大于,如果>前面的值大于后面的值,则返回 True,否则返回 False |
< | 小于,如果<前面的值小于后面的值,则返回 True,否则返回 False |
== | 等于,如果==两边的值相等,则返回 True,否则返回 False |
>= | 大于等于(等价于数学中的 ≥),如果>=前面的值大于或者等于后面的值,则返回 True,否则返回 False |
<= | 小于等于(等价于数学中的 ≤),如果<=前面的值小于或者等于后面的值,则返回 True,否则返回 False |
!= | 不等于(等价于数学中的 ≠),如果!=两边的值不相等,则返回 True,否则返回 False |
is | 判断两个变量所引用的对象是否相同,如果相同则返回 True,否则返回 False |
is not | 判断两个变量所引用的对象是否不相同,如果不相同则返回 True,否则返回 False |
赋值运算符 | 描述 | 示例 |
---|---|---|
= | 简单赋值运算 | x = 10 |
+= | 加法赋值运算 | x += 1 等同于x=x+1 |
-= | 减法赋值运算 | x -= 1 等同于x=x-1 |
*= | 乘法赋值运算 | 同上 |
/= | 除法赋值运算 | 同上 |
//= | 取整除赋值运算 | 同上 |
%= | 取余赋值运算 | 同上 |
**= | 幂赋值运算 | 同上 |
其他赋值 | 描述 | 示例 | 原方案 | 结果 |
---|---|---|---|---|
链式赋值 | 把同一个值同时赋值给多个变量名 | x=y=z=10; | z=10; y=z; x=y; | print(x,y,z); # (10, 10, 10) |
交叉赋值 | 将m与n的值交换过来 | m=10; n=20; m,n=n,m; | temp=m; m=n; n=temp; | print(m,n); # (20, 10) |
解压赋值 | 列表中的多个值取出来 依次赋值给多个变量名 (等号两边个数必须相同) | a,b,c,d,e=nums 【若只想取头尾的几个值,可以用 *_ 匹配】a,b, * _=nums; print(a,b); # (11, 22) | nums=[11,22,33,44,55]; a=nums[0]; b=nums[1]; c=nums[2]; d=nums[3]; e=nums[4]; | print(a,b,c,d,e) # (11, 22, 33, 44, 55) |
逻辑运算符 | 含义 | 基本格式 | 说明 |
---|---|---|---|
and | 逻辑与运算,等价于数学中的“且” | a and b | 当 a 和 b 两个表达式都为真时,a and b 的结果才为真,否则为假 |
or | 逻辑或运算,等价于数学中的“或” | a or b | 当 a 和 b 两个表达式都为假时,a or b 的结果才是假,否则为真 |
not | 逻辑非运算,等价于数学中的“非” | not a | 如果 a 为真,那么 not a 的结果为假;如果 a 为假,那么 not a 的结果为真。相当于对 a 取反 |
False:0 ,空字符串,空列表,空字典,空元组,空集合,None
本质:若左边 错误,则直接输出 左边 值;若左边 正确,则直接输出 右边 值。
print(100 and 200) #True
print(45 and 0) #0
print("" or "我是哒哒") #我是哒哒
print(18.8 or "我是哒哒") #18.5
成员运算符 | 描述(字符串,列表,元祖,字典,集合都支持) | 示例 |
---|---|---|
in | 某一个对象包含于另外一个对象则返回True | a = ‘hello’ in ‘hello world’ # True |
not in | 某一个对象没有包含于另外一个对象则返回True | a = ‘hello’ not in ‘hello world’ #False |
⚠️ 字典 根据键得到的值 。 print(‘a’ in {‘a’ : 123}) 结果为True print(‘123’ in {‘a’ : 123}) 结果为False
三、流程控制
python 程序可分为 三大结构:顺序结构、选择(分支)结构、循环结构
-
顺序结构 程序按照从头到尾的顺序依次执行每一条
-
选择(分支)结构 根据条件判断的真假去执行不同分支对应的子代码
-
循环结构 重复执行某段代码块
3.1 分支(选择)结构
3.1.1 三种形式
# 1. if 语句
if 表达式:
代码块
# 2. if else 语句
if 表达式:
代码块1
else:
代码块2
# 3. if elif else 语句
if 表达式1:
代码块1
elif 表达式2:
代码块2
elif 表达式3:
代码块3
else:
代码块n
在 if 判断中所有的数据类型也都会自动转换成布尔类型,None
,0
,空
(空字符串,空列表,空字典等)三种情况下转换成的布尔值为 False,其余均为 True。
三目运算:条件 ? 条件真结果 : 条件假结果;
条件为真时的结果 if 判段的条件 else 条件为假时的结果
#三目运算符的嵌套
a if a>b else c if c>d else d
应该理解为
a if a>b else ( c if c>d else d )
3.1.2 if语句嵌套
# 在最简单的 if 语句中嵌套 if else 语句
if 表达式1:
if 表示式2:
代码块1
else:
代码块2
# 在 if else 语句中嵌套 if else 语句
if 表示式 1:
if 表达式2:
代码块1
else:
代码块2
else:
if 表达式3:
代码块3
else:
代码块4
3.1.3 pass语句
pass语句作用:占位,跳过
在实际开发中,有时候我们会先搭建起程序的整体逻辑结构,但是暂时不去实现某些细节。有时候程序需要占一个位置,或者放一条语句,但又不希望这条语句做任何事情,此时就可以通过 pass 语句来实现。pass
是 Python 中的关键字,用来让解释器跳过此处,什么都不做。
3.1.4 assert断言函数
assert
语句,又称断言语句,可以看做是功能缩小版的 if 语句,它用于判断某个表达式的值,如果值为真,则程序可以继续往下执行;值为假,Python 解释器会报 AssertionError 错误。
# assert 条件,'报错的提示'
if 表达式==True:
程序继续执行
else:
程序报 AssertionError 错误
条件为真 不做任何事情,条件为假 就报错。
assert 0; #不能为0,通过命令可关闭报错
📌assert 的检查是可以被关闭的,比如在命令行模式下运行 Python 程序时,加入
-O
选项就可以使程序中的 assert 失效。一旦 assert 失效,其包含的语句也就不会被执行。
3.2 循环结构
python中有 while 与 for 两种循环机制
for循环能做的事情,while循环都能做;while循环能做的事情,for不一定能做。所以,for循环是while循环的一种优化,如果python只能保留一种应保留 while
3.2.1 while 条件循环
什么时候结束重复循环? 条件不成立时,即条件能发生变化(用变量来表示)
while 条件表达式:
代码块(循环体)
while a<10: #控制重复次数
print(a) #重复做的事情里 肯定要包含让你的次数发生变化的代码
a+=1
3.2.2 for 迭代循环
常用于遍历字符串、列表、元组、字典、集合等序列类型,依次获取序列中的各个元素 数据
for 变量名 in 可迭代对象: # 可迭代对象可以是 str\list\dict\tuple\range(),
代码一
代码二
...
#例1
for item in ['a','b','c']:
print(item)
# 运行结果
a
b
c
# 参照例1来介绍for循环的运行步骤
# 步骤1:从列表['a','b','c']中读出第一个值赋值给item(item=‘a’),然后执行循环体代码
# 步骤2:从列表['a','b','c']中读出第二个值赋值给item(item=‘b’),然后执行循环体代码
# 步骤3: 重复以上过程直到列表中的值读尽
3.2.3 循环结构中 强制结束循环
1)break
语句:终止,可以立即终止当前循环的执行,跳出当前所在的循环结构 退出
username = "jason"
password = "123"
# 记录错误验证的次数
count = 0
while count < 3:
inp_name = input("请输入用户名:")
inp_pwd = input("请输入密码:")
if inp_name == username and inp_pwd == password:
print("登陆成功")
break # 用于结束本层循环
else:
print("输入的用户名或密码错误!")
count += 1
循环嵌套+break
如果循环嵌套了很多层,要想退出每一层循环则需要在每一层循环都有一个break,即一个关键词break对应一个循环
username = "jason"
password = "123"
count = 0
while count < 3: # 第一层循环
inp_name = input("请输入用户名:")
inp_pwd = input("请输入密码:")
if inp_name == username and inp_pwd == password:
print("登陆成功")
while True: # 第二层循环
cmd = input('>>: ')
if cmd == 'quit':
break # 用于结束本层循环,即第二层循环
print('run <%s>' % cmd)
break # 用于结束本层循环,即第一层循环
else:
print("输入的用户名或密码错误!")
count += 1
username = "jason"
password = "123"
count = 0
tag = True
while tag:
inp_name = input("请输入用户名:")
inp_pwd = input("请输入密码:")
if inp_name == username and inp_pwd == password:
print("登陆成功")
while tag:
cmd = input('>>: ')
if cmd == 'quit':
tag = False # tag变为False, 所有while循环的条件都变为False
break
print('run <%s>' % cmd)
break # 用于结束本层循环,即第一层循环
else:
print("输入的用户名或密码错误!")
count += 1
2)continue
语句:中断,可以跳过执行本次循环体中剩余的代码,转而执行下一次的循环
# 打印1到10之间,除7以外的所有数字
number=11
while number>1:
number -= 1
if number==7:
continue
# 结束本次循环,即本次循环continue之后的代码都不会运行了,而是直接进入下一次循环
print(number)
3)else
当 循环正常执行完并且中间没有被break 中止的话,就会执行else后面的语句,所以我们可以用else来验证,循环是否正常结束。若执行过程中被break,就不会执行else的语句。
count = 0
while count <= 5 :
count += 1
print("Loop",count)
else:
print("循环正常执行完啦")
print("-----out of while loop ------")
输出
Loop 1
Loop 2
Loop 3
Loop 4
Loop 5
Loop 6
循环正常执行完啦 #没有被break打断,所以执行了该行代码
-----out of while loop ------
# 如果执行过程中被break,就不会执行else的语句
count = 0
while count <= 5 :
count += 1
if count == 3:
break
print("Loop",count)
else:
print("循环正常执行完啦")
print("-----out of while loop ------")
输出
Loop 1
Loop 2
-----out of while loop ------ #由于循环被break打断了,所以不执行else后的输出语句
3.2.4 循环嵌套
嵌套循环执行的总次数 = 外循环执行次数 * 内循环执行次数
# if 语句和循环(while、for)结构之间,也可以相互嵌套
i = 0
if i<10:
for j in range(5):
print("i=",i," j=",j)
# if、while、for 之间支持多层( ≥3 )嵌套
if ...:
while ...:
for ...:
if ...:
...
使用频率:int、float > list > dict > tuple
集合用的很少,除非特殊场景,集合主要用于求交集,并集,差集
四、整数类型(int)详解
4.1 数字相关的类型
十进制 二进制 八进制 十六进制
a = 123
print(bin(a)) #10进制转换为2进制
print(oct(a)) #10进制转换为8进制
print(hex(a)) #10进制转换为16进制
'''
结果:
0b1111011
0o173
0x7b
'''
# 进制转换
int() 转成10进制的数字
float() 转成小数
a = 123_456_789 # _来分割,每隔三个数字分隔一次,看起来更美观
pint(a) # 结果为:123456789
五、字符串类型(string)详解
5.1 python支持的转义字符
转义字符 | 说明 |
---|---|
\n | 换行符,将光标位置移到下一行开头 |
\r | 回车符,将光标位置移到本行开头 |
\t | 水平制表符,也即 Tab 键,一般相当于四个空格 |
\a | 蜂鸣器响铃。注意不是喇叭发声,现在的计算机很多都不带蜂鸣器了,所以响铃不一定有效 |
\b | 退格(Backspace),将光标位置移到前一列 |
\\ | 反斜线 |
\’ | 单引号 |
\" | 双引号 |
\ | 在字符串行尾的续行符,即一行未完,转到下一行继续写 |
5.2 索引与切片⭐
- 从左到右,以 0 开始,从右往左,以 -1 开始。
- 索引:序列中,每个元素都有属于自己的编号(索引)
序列名称[索引]
- 切片:访问序列中元素的另一种方法,它可以访问一定范围内的元素,通过切片操作,可以生成一个新的序列
序列名称[起始位 : 结束位 : 步长]
起始位:默认从 0 开始,结束位:不包括自己。 - ①
[数字n]
第n个索引; ②[数字a : 数字b]
第a个到第b-1个的索引; ③[数字a : 数字b : 数字k]
第a个到第b-1个的索引,中间步长为k个
a = '我是哒哒'
print(a)
print(a[2]) # 取第2个索引的字符
print(a[0:2]) # 取出从第0开始到第2-1个索引的字符
print(a[::-1]) # 倒序
📌 字符串里面的字符只能看,不能修改
str()
转换成为字符串;in
判断是否包含;+
拼接;*
重复多次
5.3 列表常用方法 ⭐
# 1)strip() 取出字符串左右两边指定的字符,默认是空格。常用于 接受用户的输入
# lstrip() 去除左边的 rstrip() 去除右边的
a = ' 我 '
b = '***我******'
c = '***我'
print(a.strip()) # 结果:我
print(b.strip('*')) # 结果:我
print(c.strip('*')) # 结果:我
# 2)len() 得到字符串中字符的个数。常用于 密码的长度
# 3)in 和 not in 左边的字符是否在右边的字符串当中
# 4)split() 以什么符号进行分隔,默认以空格分隔,得到一个列表
# 5)字符串可以for的遍历循环
# 6)lower() 将字符串全部转成小写 upper() 将字符串全部转成大写 可用于验证码
# 7)endswith() 判断字符串是否以括号内指定的字符结尾,结果为布尔值True或False
# startswith() 判断.......................开头,结果为布尔值True或False
a = '1.jpg'
print(a.endswith('jpg')) # 结果:True
# 8)join() 按照指定的字符拼接起来形成一个新的字符串
a = '12345'
print('+'.join(a)) # 结果:1+2+3+4+5
# 9)replace() 以什么字符来替换什么字符
# 10)isdigit() 判断是否为纯数字
# 11)split() 从左到右的顺序对字符串进行切分,可以指定切割次数
# rsplit() 从右往左切割,可以指定切割次数
str5='C:/a/b/c/d.txt'
print(str5.split('/',1)) # 结果: ['C:', 'a/b/c/d.txt']
str5='a|b|c'
print(str5.rsplit('|',1)) # 结果: ['a|b', 'c']
5.4 其他操作(了解)
# 1.find,rfind,index,rindex,count
# 1.1 find:从指定范围内查找子字符串的起始索引,找得到则返回数字1,找不到则返回-1
msg='tony say hello'
print(msg.find('o',1,3)) # 在索引为1和2(顾头不顾尾)的字符中查找字符o的索引
#1
# 1.2 index:同find,但在找不到时会报错
print(msg.index('e',2,4)) # 报错ValueError
# 1.3 rfind与rindex:略
# 1.4 count:统计字符串在大字符串中出现的次数
msg = "hello everyone"
print(msg.count('e')) # 统计字符串e出现的次数
# 4
print(msg.count('e',1,6)) # 字符串e在索引1~5范围内出现的次数
# 1
# 2.center,ljust,rjust,zfill
name='tony'
print(name.center(30,'-')) # 总宽度为30,字符串居中显示,不够用-填充
# -------------tony-------------
print(name.ljust(30,'*')) # 总宽度为30,字符串左对齐显示,不够用*填充
# tony**************************
print(name.rjust(30,'*')) # 总宽度为30,字符串右对齐显示,不够用*填充
# **************************tony
print(name.zfill(50)) # 总宽度为50,字符串右对齐显示,不够用0填充
# 0000000000000000000000000000000000000000000000tony
# 3.expandtabs
name = 'tony\thello' # \t表示制表符(tab键)
print(name)
# tony hello
print(name.expandtabs(1)) # 修改\t制表符代表的空格数
# tony hello
# 4.captalize,swapcase,title
# 4.1 captalize:首字母大写
message = 'hello everyone nice to meet you!'
print(message.capitalize())
# Hello everyone nice to meet you!
# 4.2 swapcase:大小写翻转
message1 = 'Hi girl, I want make friends with you!'
print(message1.swapcase())
# hI GIRL, i WANT MAKE FRIENDS WITH YOU!
#4.3 title:每个单词的首字母大写
msg = 'dear my friend i miss you very much'
print(msg.title())
# Dear My Friend I Miss You Very Much
# 5.is数字系列
#在python3中
num1 = b'4' #bytes
num2 = u'4' #unicode,python3中无需加u就是unicode
num3 = '四' #中文数字
num4 = 'Ⅳ' #罗马数字
#isdigt:bytes,unicode
print(num1.isdigit())
# True
print(num2.isdigit())
# True
print(num3.isdigit())
# False
print(num4.isdigit())
# False
#isdecimal:uncicode(bytes类型无isdecimal方法)
print(num2.isdecimal())
# True
print(num3.isdecimal())
# False
print(num4.isdecimal())
# False
#isnumberic:unicode,中文数字,罗马数字(bytes类型无isnumberic方法)
print(num2.isnumeric())
# True
print(num3.isnumeric())
# True
print(num4.isnumeric())
# True
# 三者不能判断浮点数
num5 = '4.3'
print(num5.isdigit())
# False
print(num5.isdecimal())
# False
print(num5.isnumeric())
# False
'''
总结:
最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
如果要判断中文数字或罗马数字,则需要用到isnumeric。
'''
# 6.is其他
name = 'tony123'
print(name.isalnum()) # 字符串中既可以包含数字也可以包含字母
# True
print(name.isalpha()) # 字符串中只包含字母
# False
print(name.isidentifier()) # 检查一个字符串是否是Python有效的标识符
# True
print(name.islower()) # 字符串是否是纯小写
# True
print(name.isupper()) # 字符串是否是纯大写
# False
print(name.isspace()) # 字符串是否全是空格
# False
print(name.istitle()) # 字符串中的单词首字母是否都是大写
# False
六、列表(List)详解 ⭐⭐
可用于 存储多个数据
6.1 创建列表
1)定义列表 : []
用 ,
号隔开多个元素,这些元素可以是任意的类型 数字类型无法转成列表
#1.字符串 转换成列表
list1 = list("hello")
print(list1) #结果1:['h', 'e', 'l', 'l', 'o']
#2.元组 转换成列表
tuple1 = ('Python', 'Java', 'C++', 'JavaScript')
list2 = list(tuple1)
print(list2) #结果2:['Python', 'Java', 'C++', 'JavaScript']
#3.字典 转换成列表
dict1 = {'a':100, 'b':42, 'c':9}
list3 = list(dict1)
print(list3) #结果3:['a', 'b', 'c']
#4.区间 转换成列表
range1 = range(1, 6)
list4 = list(range1)
print(list4) #结果4:[1, 2, 3, 4, 5]
#5.创建空列表
print(list()) #结果5:[]
6.2 访问列表元素
- 索引访问列表元素的格式:
列表[索引]
listname[i] - 切片访问列表元素的格式:
列表[开始索引 : 结束索引 : 步长]
listname[start : end : step]
6.3 列表的常用方法
6.3.1 按索引存取值(正向存取+反向存取):既可存也可取
# 1.1 正向取(从左往右)
my_friends=['tony','jason','tom',4,5]
print(my_friends[0])
# tony
# 1.2 反向取(负号表示从右往左)
print(my_friends[-1])
# 5
# 1.3 对于list来说,既可按照索引取值,又可按照索引修改指定位置的值,但若索引不存在则报错
my_friends = ['tony','jack','jason',4,5]
my_friends[1] = 'martthow'
print(my_friends)
# ['tony', 'martthow', 'jason', 4, 5]
6.3.2 切片(顾头不顾尾,步长)
my_friends=['tony','jason','tom',4,5]
# 2.1 顾头不顾尾:取出索引为0到3的元素
print(my_friends[0:4])
# ['tony', 'jason', 'tom', 4]
# 2.2 步长:0:4:2,第三个参数2代表步长,从0开始,每次累加一个2即可,故取出索引0、2的元素
print(my_friends[0:4:2])
# ['tony', 'tom']
6.3.3 长度 len()
my_friends=['tony','jason','tom',4,5]
print(len(my_friends))
# 5
6.3.4 成员运算in和not in
my_friends=['tony','jason','tom',4,5]
print('tony' in my_friends)
# True
print('xxx' not in my_friends)
# True
6.3.5 添加
# 5.1 append()列表尾部追加元素
l1 = ['a','b','c']
l1.append('d')
print(l1)
# ['a', 'b', 'c', 'd']
# 5.2 extend()一次性在列表尾部添加多个元素
l1.extend(['a','b','c'])
print(l1)
# ['a', 'b', 'c', 'd', 'a', 'b', 'c']
# 5.3 insert()在指定位置插入元素
l1.insert(0,"first") # 0表示按索引位置插值
print(l1)
# ['first', 'a', 'b', 'c', 'alisa', 'a', 'b', 'c']
6.3.6 删除
# 6.1 del
l = [11,22,33,44]
del l[2] # 删除索引为2的元素
print(l)
# [11,22,44]
# 6.2 pop()默认删除列表最后一个元素,并将删除的值返回,括号内可以通过加索引值来指定删除元素
l = [11,22,33,22,44]
res=l.pop()
print(res)
# 44
res=l.pop(1)
print(res)
# 22
# 6.3 remove()括号内指名道姓表示要删除哪个元素,没有返回值
l = [11,22,33,22,44]
res=l.remove(22) # 从左往右查找第一个括号内需要删除的元素
print(res)
# None
6.3.7 reverse()颠倒列表内元素顺序
l = [11,22,33,44]
l.reverse()
print(l)
# [44,33,22,11]
6.3.8 sort()给列表内所有元素排序
# 8.1 排序时列表元素之间必须是相同数据类型,不可混搭,否则报错
l = [11,22,3,42,7,55]
l.sort()
print(l)
#[3, 7, 11, 22, 42, 55] # 默认从小到大排序
l = [11,22,3,42,7,55]
l.sort(reverse=True) # reverse用来指定是否跌倒排序,默认为False
print(l)
# [55, 42, 22, 11, 7, 3]
# 8.2 了解知识:
# 我们常用的数字类型直接比较大小,但其实,字符串、列表等都可以比较大小,原理相同:都是依次比较对应位置的元素的大小,如果分出大小,则无需比较下一个元素,比如
l1=[1,2,3]
l2=[2,]
print(l2 > l1)
# True
# 字符之间的大小取决于它们在ASCII表中的先后顺序,越往后越大
s1='abc'
s2='az'
print(s2 > s1) # s1与s2的第一个字符没有分出胜负,但第二个字符'z'>'b',所以s2>s1成立
# True
# 所以我们也可以对下面这个列表排序
l = ['A','z','adjk','hello','hea']
l.sort()
print(l)
# ['A', 'adjk', 'hea', 'hello','z']
6.3.9 循环
# 循环遍历my_friends列表里面的值
my_friends=['tony','jason','tom',4,5]
for line in my_friends:
print(line)
遍历:for x in 列表
将字符串中的每一个字符(列表中的每一个元素,字典中的每一个键,元组中的每一个元组)依次赋值给前面的变量,执行for里面的代码
📌 列表 索引 切片的取值,列表不能超出索引,否则报错
列表是可以修改的,列表[索引] = 新的值
七、字典(dict)详解
保存多个数据。 和列表的区别:列表是没有描述性质的
字典:键值对 (key-value) 的形式 键对于值有描述性的功能,一种无序的、可变的序列
{key : value, key : value}
键:只能是int, float, str, tuple,常用str;值:可以是任意的类型
主要特征 | 解释 |
---|---|
通过键来读取元素 而不是通过索引 | 字典类型有时也称为关联数组或者散列表(hash)。它是通过键将一系列的值联系起来的,这样就可以通过键从字典中获取指定项,但不能通过索引来获取 |
字典是任意数据类型的 无序集合 | 和列表、元组不同,通常将索引值 0 对应的元素称为第一个元素,而字典中的元素是无序的 |
字典是可变的,并且可以任意嵌套 | 字典可以在原处增长或者缩短(无需生成一个副本),并且它支持任意深度的嵌套,即字典存储的值也可以是列表或其它的字典 |
字典中的键必须 唯一 | 字典中,不支持同一个键出现多次,否则只会保留最后一个键值对 |
字典中的键必须 不可变 | 字典中每个键值对的键是不可变的,只能使用数字、字符串或者元组,不能使用列表 |
7.1 创建字典
7.1.1 使用 {}
创建字典
#使用字符串作为key
scores = {'数学': 95, '英语': 92, '语文': 84}
print(scores)
#使用元组和数字作为key
dict1 = {(20, 30): 'great', 30: [1,2,3]}
print(dict1)
#创建空元组
dict2 = {} # 空字典,对应False
print(dict2)
7.1.2 通过 fromkeys()
方法创建字典
# list 参数表示字典中所有键的列表(list);value 参数表示默认值,如果不写,则为空值 None
# dictname = dict.fromkeys(list列表/字符串,value=None)
knowledge = ['语文', '数学', '英语']
scores = dict.fromkeys(knowledge, 60)
print(scores)
# {'语文': 60, '数学': 60, '英语': 60}
7.1.3 通过 dict()
映射函数创建字典
a = dict(str1=value1, str2=value2, str3=value3)
# str 表示字符串类型的键,value 表示键对应的值。使用此方式创建字典时,字符串不能带引号
#方式1:列表套元组
demo = [('two',2), ('one',1), ('three',3)]
#方式2:列表套列表
demo = [['two',2], ['one',1], ['three',3]]
#方式3:元组套元组
demo = (('two',2), ('one',1), ('three',3))
#方式4:元组套列表
demo = (['two',2], ['one',1], ['three',3])
a = dict(demo)
# 向dict()函数传入列表或元组,而它们中的元素又各自是包含2个元素的列表或元组,其中第一个元素作为键,第二个作为值。
# {'two': 2], 'one': 1, 'three': 3}
keys = ['one', 'two', 'three'] #还可以是字符串或元组
values = [1, 2, 3] #还可以是字符串或元组
a = dict( zip(keys, values) )
# 通过应用 dict() 函数和 zip() 函数,可将前两个列表转换为对应的字典
# {'two': 2], 'one': 1, 'three': 3}
7.2 访问字典
1)格式:字典名[键名] dictname[key]
# 如果没有这个键,就会报错
2)格式:字典名.get(键名, 默认值) dictname.get(key[,default])
# 使用 dict 类型提供的 get() 方法来获取指定键对应的值。当指定的键不存在时,get()方法不会抛出异常
# default 用于指定要查询的键不存在时,此方法返回的默认值,如果不手动指定,会返回 None。当键不存在时,get() 返回空值 None,如果想明确地提示用户该键不存在,那么可以手动设置 get() 的第二个参数
7.3 字典的常用方法
7.3.1 按key存取值(可存可取)
# 1.1 取
dic = {
'name': 'xxx',
'age': 18,
'hobbies': ['play game', 'basketball']
}
print(dic['name'])
# 'xxx'
print(dic['hobbies'][1])
# 'basketball'
# 1.2 对于赋值操作,如果key原先 不存在 于字典,则会 新增key:value
dic['gender'] = 'male'
print(dic)
# {'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball'],'gender':'male'}
# 1.3 对于赋值操作,如果key原先 存在 于字典,则会 修改对应value的值
dic['name'] = 'tony'
print(dic)
# {'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball']}
7.3.2 长度len()、成员运算in和not in、删除
# 2、长度len
dic = {
'name': 'xxx',
'age': 18,
'hobbies': ['play game', 'basketball']
}
print(len(dic))
# 3
# 3、成员运算in和not in
print('name' in dic) # 判断某个值是否是字典的key
# True
# 4、删除 也可用del删除,但不推荐
dic.pop('name') # 通过指定字典的key来删除字典的键值对
print(dic)
# {'age': 18, 'hobbies': ['play game', 'basketball']}
7.3.3 键keys(),值values(),键值对items()
一般结合循环使用
dic = {'age': 18, 'hobbies': ['play game', 'basketball'], 'name': 'xxx'}
# 5.1 获取字典所有的key
print(dic.keys())
# dict_keys(['name', 'age', 'hobbies'])
# 5.2 获取字典所有的value
print(dic.values())
# dict_values(['xxx', 18, ['play game', 'basketball']])
# 5.3 获取字典所有的键值对
print(dic.items())
# dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])
7.3.4 循环
# 6.1 默认遍历的是字典的key
for key in dic:
print(key)
# 6.2 只遍历key,结果与6.1同
for key in dic.keys():
print(key)
# 6.3 只遍历value
for key in dic.values():
print(key)
# 6.4 遍历key与value,形成元组(key,value)
for key in dic.items():
print(key)
# x得到键,y得到值
for x,y in dic.items():
print(x,y)
7.3.5 重要的函数(总结)
# 7.1 get() 取值
dic= {'k1':'jason','k2':'Tony','k3':'JY'}
print(dic.get('k1'))
# 'jason' # key存在,则获取key对应的value值
res=dic.get('xxx') # key不存在,不会报错而是默认返回None
print(res)
# None
res=dic.get('xxx',666) # key不存在时,可以设置默认返回的值
print(res)
# 666
# ps:字典取值建议使用get方法
# 7.2 pop() 删除指定键值对
dic= {'k1':'jason','k2':'Tony','k3':'JY'}
v = dic.pop('k2') # 删除指定的key对应的键值对,并返回值
print(dic)
# {'k1': 'jason', 'kk2': 'JY'}
print(v)
# 'Tony'
# 7.3 popitem() 随机删除一组
dic= {'k1':'jason','k2':'Tony','k3':'JY'}
item = dic.popitem() # 随机删除一组键值对,并将删除的键值放到元组内返回
print(dic)
# {'k3': 'JY', 'k2': 'Tony'}
print(item)
# ('k1', 'jason')
# 7.4 update() 新增/修改
# 用新字典更新旧字典,有则修改,无则添加
dic= {'k1':'jason','k2':'Tony','k3':'JY'}
dic.update({'k1':'JN','k4':'xxx'})
print(dic)
# {'k1': 'JN', 'k3': 'JY', 'k2': 'Tony', 'k4': 'xxx'}
# 7.5 fromkeys()
dic = dict.fromkeys(['k1','k2','k3'],[])
print(dic)
# {'k1': [], 'k2': [], 'k3': []}
# 7.6 setdefault()
# 1) key不存在 则新增键值对,并将新增的value返回
dic={'k1':111,'k2':222}
res=dic.setdefault('k3',333)
print(res)
# 333
print(dic) # 字典中新增了键值对
# {'k1': 111, 'k3': 333, 'k2': 222}
# 2) key存在则 不做任何修改,并返回已存在key对应的value值
dic={'k1':111,'k2':222}
res=dic.setdefault('k1',666)
print(res)
# 111
print(dic) # 字典不变
# {'k1': 111, 'k2': 222}
八、元组(tuple)详解
元组和列表(list)的不同之处在于:
- 列表的元素是可以更改的,包括修改元素值,删除和插入元素,所以列表是可变序列
- 而元组一旦被创建,它的元素就不可更改了,所以元组是不可变序列
元组也可以看做是不可变的列表,通常情况下,元组用于保存无需修改的内容
从形式上看,元组的所有元素都放在一对小括号( )
中,相邻元素之间用逗号,
分隔 (元素 , 元素 , ...)
8.1 创建元组
1)使用 ( )
直接创建 : 元组名(元素, 元素, …)
⚠️ 如果只有一个元素,也必须加一个
,
否则就不是元组类型,元素是什么类型就是什么类型
2)使用tuple()
函数创建元组:tuple(data)
#将字符串转换成元组
tup1 = tuple("hello")
print(tup1)
#将列表转换成元组
list1 = ['Python', 'Java', 'C++', 'JavaScript']
tup2 = tuple(list1)
print(tup2)
#将字典转换成元组
dict1 = {'a':100, 'b':42, 'c':9}
tup3 = tuple(dict1)
print(tup3)
#将区间转换成元组
range1 = range(1, 6)
tup4 = tuple(range1)
print(tup4)
#创建空元组
print(tuple())
8.2 修改元组
元组是不可变序列,元组中的元素不能被修改,所以我们只能创建一个新的元组去替代旧的元组
可以通过连接多个元组(使用+
可以拼接元组)的方式向元组中添加新元素
tup1 = (100, 0.5, -36, 73)
tup2 = ( -54.6, 99)
print(tup1+tup2)
print(tup1)
print(tup2)
# 使用+拼接元组以后,tup1 和 tup2 的内容没法发生改变,这说明生成的是一个新的元组
8.3 元组和列表的区别
1)最大的区别:列表中的元素可以进行任意修改;元组中的元素无法修改,除非将元组整体替换掉。tuple 元组是一个只读版本的 list 列表。
2)元组的性能速度要优于列表
# 对于列表和元组来说,虽然它们都是空的,但元组却比列表少占用 16 个字节
listdemo = []
print(listdemo.__sizeof__())
# 40
tupleDemo = ()
print(tupleDemo.__sizeof__())
# 24
由于列表是动态的,它需要存储指针来指向对应的元素(占用 8 个字节)。另外,由于列表中元素可变,所以需要额外存储已经分配的长度大小(占用 8 个字节)。但是对于元组,情况就不同了,元组长度大小固定,且存储元素不可变,所以存储空间也是固定的。
通过对比列表和元组存储方式的差异,可得出结论:元组要比列表更加轻量级,所以从总体上来说,元组的性能速度要优于列表
3)元组的 不可替代性 体现在以下这些场景中:
- 元组作为很多内置函数和序列类型方法的返回值存在,即 在使用某些函数或者方法时,它的返回值会元组类型,因此你必须对元组进行处理
- 元组比列表的访问和处理速度更快,因此,当需要对指定元素进行访问,且不涉及修改元素的操作时,建议使用元组
- 元组可以在映射(和集合的成员)中当做“键”使用,而列表不行
九、集合(set)详解
用来保存不重复的元素,即集合中的元素都是唯一的,互不相同。集合主要用于:去重、关系运算
从形式上看,集合会将所有元素放在一对大括号 {}
中,相邻元素之间用 ,
分隔 {元素 , 元素 , ...}
从内容上看,同一集合中,只能存储不可变的数据类型,包括整形、浮点型、字符串、元组,无法存储列表、字典、集合这些可变的数据类型,否则 Python 解释器会抛出 TypeError 错误
定义:在{}内用逗号分隔开多个元素,集合具备以下
⭐三个特点:
1. 每个元素必须是不可变类型
2. 集合内没有重复的元素 去重处理
3. 集合内元素无序
9.1 创建set集合
1)使用 {} 创建:集合名 = {元素, 元素, 元素, ...}
setname = {element1,element2,…,elementn}
2)set()函数创建集合:集合名 = set(字符串、列表、元组、range 对象等数据)
setname = set(iteration)
9.2 访问set集合元素
由于集合中的元素是无序的,因此无法向列表那样使用下标访问元素。Python 中,访问集合元素最常用的方法是使用循环结构,将集合中的数据逐一读取出来
a = {1,'c',1,(1,2,3),'c'}
for ele in a:
print(ele,end=' ')
9.3 集合的常用方法
9.3.1 关系运算
合集/并集( |
)、交集( &
)、差集( -
)、对称差集( ^
)、值是否相等( ==
)、父集、子集
friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们
friends2 = {"Jy","ricky","jason","egon"} # 用户2的好友们
# 1.合集/并集(|):求两个用户所有的好友(重复好友只留一个)
print(friends1 | friends2)
# {'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}
# 2.交集(&):求两个用户的共同好友
print(friends1 & friends2)
# {'jason', 'egon'}
# 3.差集(-):
print(friends1 - friends2) # 求用户1独有的好友
# {'kevin', 'zero'}
print(friends2 - friends1) # 求用户2独有的好友
# {'ricky', 'Jy'}
# 4.对称差集(^) # 求两个用户独有的好友们(即去掉共有的好友)
print(friends1 ^ friends2)
# {'kevin', 'zero', 'ricky', 'Jy'}
# 5.值是否相等(==)
print(friends1 == friends2)
# False
# 6.父集:一个集合是否包含另外一个集合
# 6.1 包含则返回True
print({1,2,3} > {1,2})
# True
print({1,2,3} >= {1,2})
# True
# 6.2 不存在包含关系,则返回False
print({1,2,3} > {1,3,4,5})
# False
print({1,2,3} >= {1,3,4,5})
# False
# 7.子集
print({1,2} < {1,2,3})
# True
print({1,2} <= {1,2,3})
# True
9.3.2 去重
集合去重的局限性:① 只能针对不可变类型; ② 集合本身是无序的,去重之后无法保留原来的顺序。
l=['a','b',1,'a','a']
s=set(l)
print(s) # 将列表转成了集合
# {'b', 'a', 1}
l_new=list(s) # 再将集合转回列表
print(l_new)
# ['b', 'a', 1] # 去除了重复,但是打乱了顺序
# 针对不可变类型,并且保证顺序则需要我们自己写代码实现,例如
l=[
{'name':'lili','age':18,'sex':'male'},
{'name':'jack','age':73,'sex':'male'},
{'name':'tom','age':20,'sex':'female'},
{'name':'lili','age':18,'sex':'male'},
{'name':'lili','age':18,'sex':'male'},
]
new_l=[]
for dic in l:
if dic not in new_l:
new_l.append(dic)
print(new_l)
# 结果:既去除了重复,又保证了顺序,而且是针对不可变类型的去重
# [
# {'age': 18, 'sex': 'male', 'name': 'lili'},
# {'age': 73, 'sex': 'male', 'name': 'jack'},
# {'age': 20, 'sex': 'female', 'name': 'tom'}
# ]
9.3.3 其他操作
# 1.长度
s={'a','b','c'}
print(len(s))
# 3
# 2.成员运算
print('c' in s)
# True
# 3.循环
for item in s:
print(item)
十、可变类型与不可变类型
-
可变数据类型:值发生改变时,内存地址不变,即id不变,证明在改变原值 [列表,字典,集合]
-
不可变类型:值发生改变时,内存地址也发生改变,即id也变,证明是没有在改变原值,是产生了新的值 [数字,字符串,元祖]
📌 扩展知识点:
- 只要内容更改,内存地址就更改,ID变化
int float str tuple
- 只要发生修改,内存地址就马上修改 ==> 不可变数据类型
- 发生了修改,内存地址不会发生变化 ==> 可变数据类型 list dist set
- 元组不能修改,指的是元组内部元素的内存地址不能修改。若元组的元素是列表/字典,列表/字典的修改不会更改内存地址。(不建议使用,装逼知识点😎)