python基础
1 python安装
本次学习基于 python3.8
python支持多平台,包括Windows,unix,和mac,python的官方安装程序源下载 https://www.python.org/ftp/python/ python和linux的shell一样,属于解释型语言,其官方帮助文档 https://docs.python.org/zh-cn/3.8/
1.1 在linux平台安装python
# 安装依赖包 yum -y install gcc patch libffi-devel python-devel zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel xz-devel # 上传python3.8源码包至用户目录下,解压后,进入目录,编译安装,并创建软链接 tar -zxf Python-3.8.0b3.tgz cd Python-3.8.0b3/ ./configure --prefix=/usr/local/python3 make && make install ln -s /usr/local/python3/bin/python3.8 /usr/bin/python3 ln -s /usr/local/python3/bin/pip3.8 /usr/bin/pip3
1.2 在Windows平台安装python
省略
2 python中的变量及注释
python属于动态类型的语言,不像C,C++需要声明变量的类型.变量名是无关数据类型的,但变量名所指向的值则是类型相关的,值的类型可以是数字,字符串,列表,字典,元组,函数,类,对象等等.
每个变量在使用前必须赋值,变量赋值的实质就是在内存中创建内存空间,使用时通过变量名引用.
这些内存对象中至少包含3个部分:
1)对象类型type
2)对象的引用计数(用来判断对象是否可被垃圾回收器回收)
3)对象的值
变量的3个基本特征:
1)id :地址编号(反映出变量在内存中的编号,非真正的物理内存地址)
2)type :类型(value值的类型)
3)value :值的内容/元素
小结变量:
1)id相同，type和value值一定相同;而value值和type值相同,id可能不同.
2)is比较的是id身份,即内存地址;而 == 比较的是value值是否相同/等.
3)可以同时为多个变量赋值,如a,b=1,'hello',通过多个变量同时赋值,可以将其指向不同类型的对象,如:
a,b,c=1,2,'xixi' #<===a和b都是整型,c赋值给字符串xixi
2.1 变量的命名规范
1)变量名只能是字母、数字或下划线的任意组合.
2)变量名的第一个字符不能是数字,只能以字母或下划线 _ 开头,以 _ 开头的有特殊意义.
3)关键字不能声明为变量名.
4)常量:python中没有绝对的常量,某些约定俗成,变量名一般使用全大写字母表示常量.
python中保留的关键字: 使用keyword模块查看
>>>import keyword #<===import用于导入模块 >>>print(keyword.kwlist) ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
2.2 python中的注释和文件头
共有3种表示注释的方法:
# 注释的内容 <===第一种,使用 # 注释 ''' 注释的内容 <===第二种,使用2个三单引号,中间是注释的内容 ''' """ 注释的内容 <===第三种,使用2个三双引号,中间是注释的内容 """
文件头:
#!/usr/bin/env python <===指定解释器 # -*- coding: utf-8 -*- <===指定字符编码
2.3 变量的解压
l=[1,2,3,4,5] a,b,c,_,_=l #使用一个下划线 _ 表示单个元素(在某种意义上,被代表的元素代表着被抛弃) a,*_,e=l #使用 *_ 表示多个元素 *_,e=l #使用 *_ 表示多个元素(一般在前在后都可以使用此种方式取前后需要的值,中间的尽量使用土办法取) a,*_=l print(l) print(a) print(*_) #有定义,才可以取值 #print(d) #此种取值是错的,因为没有定义 ---------------- [1, 2, 3, 4, 5] 1 2 3 4 5
3 其他
3.1 用户交互input(),等待用户的输入
input() 作用:接收用户的输入,并把输入的内容转成str()字符串类型;一旦用户输入enter键,程序将会退出.
注意:
#在python3中 input() <===用户输入任何值，都默认存为字符串类型 #在python2中 input() <===用户输入什么类型，就存成什么类型,必须明确指明输入的数据为哪种类型 raw_input() <====>等于python3.x的input,在python2.x都使用这个比较多
python3.x中input()示例：
age=18
inp_age=input('输入年龄：')
inp_age=int(inp_age) #数据类型转换
if inp_age > age:
print('年龄大')
elif inp_age < age:
print('年龄小')
else:
print('年龄正确')
3.2 同一行显示多条语句 ;
python可以在同一行中使用分号 ; 分隔多条语句(类似linux),如:
>>>print('asd');print('213654')
asd
213654
3.3 print()输出
print()输出默认是自动换行的,如果想不换行,只需要在变量的末尾加上 end=' ' (也可以是双引号" "),表示打印输出不换行,以空格分隔.
print(end='\n') #<===默认是自动添加换行符 print(end=' ') #<===留一个空格,表示打印不换行,并以空格分隔 print() #<===换行,等价于print(end='\n'),默认省略end=’\n’
实例:
a='asd'
b='fds'
print(a)
print(b)
print('不换行输出')
print(a,end=" ")
print(b,end=' ')
#print()
------------结果:
asd
fds
不换行输出
asd fds
3.4 行与缩进
1)python使用缩进表示代码块层次,不像其他语言使用 {} .
2)缩进的代码块的空格数是可变的,但是同一个代码块的语句必须包含相同的缩进空格数,最好不要混用空格和tab键.
3)如果缩进的空格数不一致,可能导致运行错误,或者得不到想要的结果.
4)如果代码部分只有一个语句,可以直接放在声明行冒号的后面,如 if True:pass
5)python中可以使用小括号(),中括号[],大括号{}让代码换行续写,使用反斜线 \ 也可以,但不建议使用 \ ,如:
a=1
b=2
c=3
counts =a + \ #<===不建议使用 \ 续行
b + \
c
print(counts)
------------------------------------------------
counts = ['a','b','c',
'd'] #<===使用(),[],{}可以随意换行
print(counts)
3.5 可变和不可变类型
可变类型：在id不变的情况下,value可以变,则称为可变类型,如列表,字典,集合,可变类型不可hash,即unhashable.
1)列表,不可hash
2)字典,不可hash
3)集合,不可hash
不可变类型：value一旦改变,id也改变,则称为不可变类型（id变，意味着创建了新的内存空间）,不可变类型可hash.
1)数字(整型,浮点型),可hash
2)字符串,可hash
print(hash(10)) print(hash([1,2,3])) 10 --------------------- Traceback (most recent call last): File "D:/python/untitled/test.py", line 194, in <module> print(hash([1,2,3])) TypeError: unhashable type: 'list'
3.6 赋值方式补充
交叉赋值:
m=1 n=2 x=m m=n n=x # 等价于 m=1 n=2 m,n=n,m -------------- print(m,n)
连续同时多个赋值:
m,n=1,2 print(m,n)
链式赋值
x=y=z=1
3.7 数据类型的方法和python内置函数如何区分
# 数据类型的方法: 数据类型.方法()
s=' abcdef**** '
print(s.strip(' *'))
# python内置函数
print(len(s)) #数据通过变量名引用在内置函数内
4 python中的基本运算符
分以下几个类别:
算术运算符 比较（关系）运算符 赋值运算符 逻辑运算符 位运算符 成员运算符 身份运算符 运算符优先级
4.1 算术运算符
4.2 比较运算符
4.3 赋值运算符
4.4 位运算符
4.5 逻辑运算符
4.6 成员运算符
4.7 身份运算符
4.8 运算符优先级
5 python中的基本数据类型
分以下几个类别:
数字int():(整型int,长整型long(限python2.x),布尔值bool,浮点型float,复数complex)--->属于不可变类型 字符串str()--->不可变类型 字节串(字符编码bytes类型)---不可变类型 列表list()--->可变类型 元组tuple()--->不可变类型 字典dict()--->可变类型,key不可变,value值可变 集合set()--->可变类型,但其元素只能是不可变类型(只能是数字和字符串类型(意味着不可内嵌可变类型数据(列表,字典,集合)))
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
5.1 数字类型
整型int()
在python3.x中,没有长整型long的概念(python2.x中才有),统一使用int表示整数(取整),不带小数点.
用途:用来表示号码,等级,年龄,身份证号码等相关整数数字.
整型属于不可变类型,改变了意味着创建了新的内存空间;只可以存一个值;不可分割;但可hash.
#定义的方法: age=20 <===> age=int(20) #删除对象引用(同时删除多个使用逗号分隔),或赋新值 del age
浮点型float()
浮点型由整数和小数部分组成,也可以使用科学记数法表示(如-12.12e100).
用途: 用来表示体重,身高,财务计数等
浮点型属于不可变类型,只能存一个值,不可分割,但可hash.
#定义的方法float(): hight=1.8 <===> hight=float()
复数complex()
复数是高中的知识,由实数和虚数组成,complex(a,b)等价于a+bj,其中a是复数的实部,b是复数的虚部,a和b都是浮点型.
5.1.1 python数字类型之间的转换
int(a) #<===将a转换为一个整数 float(a) #<===将a转换为一个浮点数 complex(a) #<===将a转换为一个复数,实数部分为a,虚数部分为0 complex(a,b) #<===将a,b转换到一个复数,实数部分为a,虚数部分为b,a和b是数字表达式.
5.1.2 python整数之间的进制转换
整数除了十进制整数外,还可以用二进制,八进制,十六进制来表示,他们之间的转换关系如下:
#当一个整数以0b或0B开头，其后都是0、1时，默认识别为二进制整数
#当一个整数以0o或0O开头(数值零和大、小写的字母o)，其后都是0-7之间的数值时，默认识别为8进制整数
#当一个整数以0x或0X开始，其后都是[0-9a-fA-F]之间的字符时，默认识别为十六进制
#进制整数的转换
bin()：十进制整数转换成二进制
oct()：十进制整数转换成八进制
hex()：十进制整数转换成十六进制整数
#如:
>>> bin(128);oct(128);hex(128)
'0b10000000'
'0o200'
'0x80'
#使用int()函数也可以完成进制之间的转换,使用格式为
int(x,base=10)
#不指定base,默认为10进制,base的值在0-36之间的任意整数,base=0即十进制,如:
>>> int('1000000',base=2)
64
5.1.3 python内置数学函数
pow()：求幂，如pow(2,3)=8 abs()：求绝对值，如abs(-3)=3 round()：四舍五入，如round(3.5)=4 int()：取整(截去小数部分)，如int(3.5)=3 float()：转换成浮点数，如float(3)=3.0 oct()：十进制整数转换成八进制 hex()：十进制整数转换成十六进制整数 bin()：十进制整数转换成二进制 sqrt() : 返回给定数字的平方根 ...... 等等
5.2 字符串str()
str()字符串用途:使用字符串表示描述性的数据,如名字,国籍,性别,学历等.
字符串属于不可变类型,可hash,在python3.x中,字符串都是16位Unicode存储.
字符串定义方法:在单引号\双引号\三引号内，由一串字符组成,如:
name='tim' <===> 等同于age=str(tim) print(id(name),type(name),name) 39596976 <class 'str'> tim a1='xixi' #<===单/双/三引号,单双引号没有任何区别,有时候需配和使用,多行字符串使用2对3个单/双引号 a2="xixi2" #<===外面用单引号,内就要用双引号,单双引号最好成对出现 a3=""" xixixixi """ a4=''' asdasd ''' print(a1,a2,a3)
5.2.1 字符串运算符
注意:尽量不要使用字符串拼接操作,因为会开辟新的内存空间,极度浪费内存资源.
5.2.2 字符串按照索引取值中字符
字符串中的值的字符有特定的索引,可以正向取,或反向取,但不能更改,因为字符串是不可变类型数据.
字符串的值只能有一个,即只能存一个值.
字符串截取语法格式: 变量[头下标:尾下表] ,字符串的截取遵循 顾头不顾尾 的法则,类似数学中的[)
实例:
test='abcdef' #取字符串中字符使用冒号 : 分隔取值,顾头不顾尾,即数学中的[) print(test) #输出字符串 print(test[0]) #输出字符串第一个字符,正向从0,1,2,3,... print(test[0:-1]) #输出第一个字符到倒数第二个的所有字符 print(test[1:3]) #输出从第二个开始到第三个的字符 print(test[2:]) #输出第三个字符到最后的所有字符,此时尾没有指定,就包含所有 print(test[:5]) #输出第六个字符前的所有字符,,不包含第六个字符,不顾尾 print(test + 'ghijk') #字符串拼接 print(test * 2) #字符串乘法,输出多少次字符串,并连接在一起 print(test[-3:-1]) #反向截取字符,倒数第二个和第三个字符 print(test[-1:-3]) #这样截取是没有结果的,反向截取,按照截取的数字大小,顺序最小的必须总是在[]左边(除非指定步长为负整数,如-2) #<===结果 abcdef a abcde bc cdef abcde abcdefghijk abcdefabcdef de #print(test[-1:-3])结果为空
字符串正反向取单个字符实例:
test='abcdef' print(test[0]) print(test[1]) print(test[5]) print(test[-1]) print(test[-6]) #<===结果 a b f f a
5.2.3 字符串切片
特点:利用索引将字符分片取值,默认步长为1,正向切片取值(省略不写),从左往右从0,1,2,...开始;反向切片取值从-1,-2,-3,...开始.
指定步长切片,默认步长为1正向.如果步长为2,则间隔一个位置,以此类推.
字符串切片同样遵循 固态不顾尾 的法则,如:
字符串 test='abcdef'
test='abcdef' print(test[1:4:2]) #正向切片取值,步长为2,从第二个字符开始,中间间隔一个字符取值,结果为bd print(test[-1:-5:-2]) #反向切片取值,指定步长为-2,结果为fd print(test[::-1]) #反向取值,结果为fedcba print(test[::1]) #正向取值,结果为abcdef print(test[::]) #正向取值,默认可以省略的步长1,结果是abcdef --------------------- bd fd fedcba abcdef abcdef
5.2.4 统计字符串个数函数len()
len()函数可以统计字符串个数,包含空格.
test='abcdef' print(len(test)) --------------- 6
5.2.5 成员运算in和not in
in和not in用于判断一个子字符是否是字符串的成员.容如果是,则返回True,否则,返回False.
test='abcdef'
print('a' in test) #True
print('x' in test) #False
print('a' not in test) #False
5.2.6 移除空白函数strip()
用于移除字符串内的空格或其他特殊符号(如*号),注意字符串是不可变类型,重新赋值会开辟新的内存空间.
strip()函数,默认过滤的符号是空格(空格可不加),如果要过滤其他字符串,在strip()小括号内指定,注意必须加引号指定要过滤的字符串.
strip()函数仅仅是过滤多余的特殊符号,不会产生新值(因为字符串属于不可变类型).
strip()函数如果需要过滤多个不同的字符串必须遵循:先过滤两边的,再过滤中间的.
name=input('名字:')
print(name.strip()) #交互式输入中可以去除特殊符号
-----------------------------------------
s='***abc***'
print(s.strip('*')) #结果为abc,把*号过滤掉了
print('sss****####'.strip('#').strip('*')) #结果为sss
# 优化输入
name=input('输入的内容:').strip()
# 同时过滤多个特殊符号
name=input('备注信息:').strip(' *#')
5.2.7 字符串切分方法split()
用于字符串类似 a='xiaomi:123:admin' 切分,如:
test='xiaomi:123:admin'
tes=test.split(':')
print(tes,type(tes))
print(tes[0])
print(tes[1])
print(tes[2])
----------------结果
['xiaomi', '123', 'admin'] <class 'list'> #切分后成为了列表类型
xiaomi
123
admin
---------------
test='xiaomi|123|a.txt'
print(test.split('|'),type(test))
----------------结果
['xiaomi', '123', 'a.txt'] <class 'str'> #可以逗号隔开，指定切分的次数，如's'.spilt('|',1)
切分后如何还原?使用join()函数可以还原,如:
test='xiaomi|123|a.txt'.split('|')
print(test)
test2='|'.join(test) #指定分隔符,使用join()函数还原
print(test2,type(test2))
-----------------------------
['xiaomi', '123', 'a.txt']
xiaomi|123|a.txt <class 'str'>
注意：字符串join方法传入的列表必须只包含str类型的元素.
5.2.8 利用if,while,for等语句取值
依赖索引方法:while语句+比较运算符
s='asd'
i=0
while i < len(s):
print(s[i])
i+=1
-------------
a
s
d
不依赖索引:使用for迭代循环取值
msg='asd'
for i in msg:
print(i)
-------------
a
s
d
enumerate()函数会把索引及对应的值打印出来,enumerate()取值,结果类似(0,'a') (1,'b')这种形式:
for x,y in enumerate('123456'):
print(x,y)
-----------------
0 1
1 2
2 3
3 4
4 5
5 6
# enumerate()的结果就是(index,value)的形式
l=list(enumerate('aabbcc'))
print(l)
-----------------
[(0, 'a'), (1, 'a'), (2, 'b'), (3, 'b'), (4, 'c'), (5, 'c')]
注意:for迭代循取值,不支持数字类型(整型,浮点型等),如 for i in 123:是错误的.
5.2.9 字符串查找
find() 自左向右查找,结果显示起始位置, 找不到就显示 -1.
rfind() 自右向左查找,结果显示是起始位置,找不到就显示 -1.
index() 使用,如果字符串内没有此字符,则会报错,显示substring not found.
实例:
t='aaa bbb ccc'
print(t.find('b')) #查找到的是起始位置,b从第个位置开始
print(t.find('b',0,10)) #在指定区间查找内字符的起始位置
print(t.rfind('b',4,9)) #在指定区间内查找字符的起始位置
print(t.index('c',8,12)) #同上,但查找不到会报错,不会显示-1
--------------------------
4
4
6
8
5.2.10 字符串填充
center() #以中间为中心,向两边填充 rjust() #从右开始往左边填充 ljust() #从左开始往右填充 zfill() #用数字0填充,数字0全部在左边
实例:
#<===注意, center()中填充的符号只能是单个,多个会报错,且必须加引号,这个是字符在中间
print('asd'.center(10,'*')) #共10个字符
>>> ***asd****
# 左/右对齐
print('asd'.ljust(11,'*')) #从左边开始,往右边填充
print('asd'.rjust(11,'*')) #从右边开始,往左边填充
print('asd'.zfill(11)) #使用数字0填充,zfill代表0
>>>asd********
>>>********asd
>>>00000000asd
5.2.11 python字符串中的转义符与raw字符串
和linux一样,在python中也使用反斜线 \ 代表转义字符,如表:
在字符串中,也可以使用 r 来声明后面的字符串是raw字符串,从而使能后面的所有字符不会进行任何转义.
实例演示制表符 \t 和换行符 \n 和raw字符串使用:
a='sad\tasd' #使用制表符\t print(a) #一般制表符代表4个空格,前面的字符已经占3个,所有结果只有一个空格 print(len(a)) #字符串数量为7 print(r'abc\tabc') #使用r后面的字符串不会进行转义或者换行操作 print(r'aaa\nbbb') #并且\t和\n都保留原值 print(len(r'aaa\tbbb')) #\t不会被转义 ----------------------- sad asd 7 abc\tabc aaa\nbbb 8 -----------------------
注意:raw字符串不能以反斜线结尾,除非对其转义.例如r'abc\ndef\'是错误语法,但r'abc\ndef\\'是正确的语法,它表示后面有两个反斜线字符.
其他示例:换行\n,tab键\t和expandtabs()方法,注意:字符串多行一般使用多引号,避免使用 \n换行 或 \ 续行.
msg='abc\tasd' #\t指定tab键 print(msg.expandtabs(3)) #指定tab键代表的空格数 ------------------- abc asd #一般一个\t代表4个空格,前面3个字符已经占用了3个空格,所以只剩一个 ------------------- msg='abc\nasd' #\n换行 print(msg.expandtabs()) ------------------- abc asd
5.2.12 字符串格式化
类似传参,将后面的值赋给前面的参数,如:
print('my name is %s' %('asd',))
print('my name is {} {} {}'.format('a','g','d'))
print('my name is {x} {y} {z}'.format(x='sasd',z='asfg',y='asdfd'))
--------------------------------------
my name is asd
my name is a g d
my name is sasd asdfd asfg
5.2.13 字符串之间的比较
按照位置依次比较,首先比较第一个字母的大小,相同则往后推移,比较的结果不是返回True就是False,如:
s1='hello'
s2='z'
print(s1 > s2)
>False #这些比较有些要看ASCII码表
print('Z' > 'a')
print('a' > 'B')
>False
5.3 python字符串的常见内置方法
使用 print(dir(str)) 可以输出字符串常见的内置方法:
print(dir(str)) ----------------------------------------- ['暂时将_下划线开头的省略'', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
5.3.1 字符串大小写转换
以下中S代表字符串:
S.lower() :返回S字符串的小写格式(即把字符串S中的大写字母转换为小写字母) S.upper() :返回S字符串的大写格式(即把字符串S中的小写字母转换为大写字母) S.title() :返回S字符串所有单词首字母大写,其他小写字母的格式(即把首字母大写,空格分隔的首字母都大写) S.capitalize() :返回S字符串词首字母大写,其他字母小写的格式(仅仅是字符串词首字母大写,其他都是小写) S.swapcase() :将大小写字母反转(大写变小写,小写变大写)
print('AAA'.lower())
print('aaa'.upper())
print('abc is abc'.title())
print('abc is abc'.capitalize())
print('abc IS AbC'.swapcase())
---------------
aaa
AAA
Abc Is Abc
Abc is abc
ABC is aBc
5.3.2 字符串判断 isxxx相关
实际代码中,可以使用isxxx+if条件判断,判断用户的输入,常用的是 S.isdigit().
print('111'.isdecimal()) #判断字符串是否是阿拉伯数字,是返回True,否则返回False(只能判断unicode的阿拉伯数字)
print('123'.isdigit()) #判断字符串是否是阿拉伯数字,是返回True,否则返回False(判断bytes和Unicode的阿拉伯数字)
print('123'.isnumeric()) #判断字符串是否是数字,是返回True,否则返回False(判断Unicode的阿拉伯数字/中文数字/罗马数字)
print('asd'.isalpha()) #判断字符串是否是字母,是返回True,否则返回False
print('asd'.isalnum()) #判断字符串是否是字母,是返回True,否则返回False
print('a1b2'.islower()) #判断字符串字母是否全部小写,是返回True,否则返回False,要求字符串必须包含至少一个字母
print('AA123'.isupper()) #判断字符串字母是否全部大写,是返回True,否则返回False,要求字符串必须包含至少一个字母
print('I Am Ui'.istitle()) #判断字符串首字母是否是大写,其他必须小写,是则返回True,否则返回False.这是边界判断
print('I Am UI'.istitle()) #此时则是False
print('I 123Am Ui'.istitle()) #字符串中字母的首字母是大写,其他小写都为True
print(''.isspace()) #判断是否是空白字符(包括空格,制表符tab,换行符),是返回True,否则返回False
print('asd'.isprintable()) #判断是否可打印,是则返回True,否则返回False
print('2asd'.isidentifier()) #判断是否满足标识符定义规则,即判断是否包含python的关键字(只能是字母或下划线开头、不能包含除数字、字母和下划线以外的任意字符)
------------------------------
True
True
True
True
True
True
True
True
False
True
False
is数字系列判断:
#在python3中,字符串数字is的判断 num1=b'4' #bytes,单独的数据类型 num2=u'4' #unicode,python3中无需加u就是unicode,定义字符串默认加了u num3='四' #中文数字 num4='Ⅳ' #罗马数字 # 使用isdigit测试,bytes和阿拉伯数字可以判断出来,另外则不能判断(常用) print(num1.isdigit()) #True print(num2.isdigit()) #True print(num3.isdigit()) #False print(num4.isdigit()) #False # 使用isdecimal()判断,仅能判断Unicode的阿拉伯数字 print(num2.isdecimal()) #True print(num3.isdecimal()) #False print(num4.isdecimal()) #False # 使用isnumeric()判断,仅能判断Unicode阿拉伯数字,中文数字,罗马数字(银行算钱) print(num2.isnumeric()) #True print(num3.isnumeric()) #True print(num4.isnumeric()) #True
5.3.3 字符串填充
print('aaa'.center(5,'*')) #指定字符串总数,并指定使用*填充
print('aaa'.center(5)) #不指定填充字符,默认以空格填充
print('aaabbbccc'.center(5)) #指定的字符串长度小,默认返回字符串本身(不会创建新字符串对象)
print('aaa'.ljust(6,'*')) #指定字符串长度,以*填充,字符串在左边,填充的符号在右边
print('bbb'.rjust(6,'-')) #指定字符串长度,以-填充,字符串在右边,填充的符号在左边
print('+42'.zfill(5)) #使用数字0填充在字符串最左边,如果有+-符号,则0在+-号后面
--------------------
*aaa*
aaa
aaabbbccc
aaa***
---bbb
+0042
5.3.4 字符串搜索
S.count() :返回字符串S中sub字符出现的次数,可以指定开始和结束的区间(依赖索引,从0开始,顾头不顾尾).
S.startswith() :判断字符串S中是否以sub字符开头,是则返回True,否则返回False,同样,可以从索引中指定判断范围,顾头不顾尾.(指定了索引范围,就会在此区间内判断,顾头不顾尾)
S.endswith() :判断字符串S中是否以sub字符结尾,是则返回True,否则返回False,同样,可以从索引中指定判断范围,顾头不顾尾.(指定了索引范围,就会在此区间内判断,顾头不顾尾)
S.find() :搜索字符串S中是否包含子串sub,包含则返回sub子串的索引起始位置,否则返回 -1,不会报错.(可以指定搜索的起始和结束位置,依赖索引来搜索)
S.rfind() :返回搜索到的最右边子串sub的位置,注意无论是find还是rfind,返回的位置,都是从左往右算的,其他和find()等价.
S.index() :和find()一样,唯一不同的是,搜索不到就报错,substring not found.
S.rindex() :和rfind()一样,唯一不同的是,搜索不到就报错,substring not found.
print('aabbccdd'.count('a'))
print('abcdef'.count('a',0,5))
print('abcdefabcdef'.count('a',5)) #指定从索引5即f开始往后查找
print('aabbcc'.startswith('a',0,5))
print('aabbcc'.endswith('a',0,5))
print('abcdef'.find('c'))
print('abcdef'.rfind('e'))
print('abcdef'.index('d'))
print('abcdef'.rindex('d'))
---------------------
2
1
1
True
False
2
4
3
3
5.3.5 字符串替换
S.replace() :将原字符串中的子串替换为新子串,可以指定数量,默认从左往右替换对应数量的子串.如果找不到替换的子串,则返回当前字符串.
S.expandtabs() :将字符串中的 \t 替换为一定数量的空格,替换时,会减掉 \t 前面的字符数量;如果 \t 前面没有字符,则替换为指定数量的空格.(注意:换行符 \n 或 \r 不会替换)
S.maketrans和S.translate() :类似linux的tr命令,marketrans输出映射表,translate对此映射表中的每个字符进行映射.
t='aabbccaabbcc'
print(t.replace('aa','AA')) #不给定数量,替换所有
print(t.replace('aa','AA',1)) #给定数量,默认从左右替换给定的数量
print(t.replace('dd','DD')) #要替换的子串没有,则不替换,直接返回原字符串
print('00\t000\t0000\t00000'.expandtabs(4)) #2空格,1空格,4空格
a='abcdef' #marketsrans和translate配合完成的结果类似Linux的tr命令
b='123456'
c=str.maketrans(a,b)
test='aabbccddeeff'
result=test.translate(c)
print(result)
---------------------------
AAbbccAAbbcc
AAbbccaabbcc
aabbccaabbcc
---------------------------
00 000 0000 00000
---------------------------
112233445566
5.3.6 字符串分割
S.split() : 对字符串进行分割,默认从左往右,指定str 为分隔符截取字符串,可以指定分割次数;如果不指定或指定为None,则以空格为分隔符,并将所有空白压缩为一个空格.
S.rsplit() :和split一样,只是方向相反,从右往左切分.
S.splitlines() :用来专门分割换行符.
S.partition() :指定子串为分割处,对S进行分割,最后返回一个包含3元素的元组;如果分割子串不存在,则返回的元组有2个元素为空.
S.rpartition() :同partition(),只是方向相反.
print('a,a,a'.split(','))
print('a,a,a'.split(',',1)) #以冒号分割,只分割一次
print('a,a,a'.split('a,')) #指定多个分割符
print('aabbccaabbcc'.partition('cc'))
--------------------
['a', 'a', 'a']
['a', 'a,a']
['', '', 'a']
('aabb', 'cc', 'aabbcc')
5.3.7 join
S.join(str) : 将可迭代对象中的元素使用S连接起来,括号中必须为字符串str类型,不能是数字或其他类型数据.
l='get|a.txt|333'.split('|') #字符串切分为列表
print(l)
l_new='|'.join(l) #列表整合为字符串
print(l_new)
-----------------
['get', 'a.txt', '333']
get|a.txt|333
5.3.8 字符串修剪(重复)
S.strip() : 移除左右两边的多余符号,如空格,*,-等,也可以移除字符子串,如果子串是多个,只要是这个字符串的子串,都会被移除.如果不指定移除或者为None,则默认为移除空白(空格,制表符,换行符),会新申请内存空间.
S.lstrip() : 同上,但只移除左边的.
S.rstrip() : 只移除右边的.
print(' aa '.strip() ) #默认移除空格,制表符,换行符
print('aabbcc'.strip('a')) #移除子串
print('ccaabbcc'.lstrip('c')) #移除左边子串
----------------
aa
bbcc
aabbcc
5.4 字符串格式化输出
分3种: 格式化表达式,format()及format()函数,这3种的玩法大致如下:
# 第一种玩法 %s 即可以传字符串,又可以传数字(int),注意 %s 如果传递没有对应的值,则会报错
print('my name is %s' %('aaa'))
# 第二种玩法,使用大括号 {} 代替 %s ,对应传递值,没有对应的值,则会丢弃,不会影响使用
print('my name is {} and my age is {}'.format('AAA',20,21)) # 21会被丢弃
# 第三种玩法,使用数字对应参数传递,{}大括号内使用数字代表后传递的参数,类似索引代表的值
print('my name is {0} and my age is {1}'.format('BBB',20))
print('my name is {1} and my age is {1}'.format('BBB',20))
# 第四种玩法,使用变量名对应传递的参数(使用最多),相当于key:value 的形式
print('my name is {a} and my age is {b}'.format(a='CCC',b=20)) #不用考虑位置
-----------------------------------------
my name is aaa
my name is AAA and my age is 20
my name is BBB and my age is 20
my name is 20 and my age is 20
my name is CCC and my age is 20
5.4.1 格式化表达式
格式化表达式在字符串中使用百分号 % 作为占位符,使用上类似printf命令的风格.
注意:字符串格式化必须在后面添加引用,如%(name,age),将后面变量对应的值传递给前面.但如果后面传递的参数不够,或者少了,会直接报错.
a1='shuaige'
a2='meinv'
print('your are a %s' %a1)
print('your are a %s' %a2)
print('you are a %s %s' %(a1,a2)) #可以使用多个%分隔,替换多个(使用括号包围)
print('%(t1)s' '%(t2)s' %{'t1':'aaa','t2':'bbb'}) #可以使用变量,字符串中%可以是key,替换的目标可以是字典(key:value)
------------------
your are a shuaige
your are a meinv
you are a shuaige meinv
aaabbb
------------------实例2:
name=input('输入你的名字:')
age=int(input('输入你的年龄:'))
sex=input('输入你的性别:')
job=input('输入你的工作:')
msg="""
------info of %s-------
Name : %s
Age : %s
Sex : %s
Job : %s
------end--------------
""" %(name,name,age,sex,job) #必须在后面使用 % 传递对应的值给前面,且传递的数量不能多也不能少,否则报错
print(msg)
5.4.2 字符串格式化format()
使用format格式化字符串时,需要使用大括号 {} 作为占位符,占位符中的内容将引用format()中的参数(位置/命名参数)进行替换.
t='{0},{1},aaa {2}'
print(t.format('aaaa','bbbb','cccc')) #位置参数
print('{a1},{a2},qqq {a3}'.format(a1='aaa',a2='bbb',a3='ccc')) #命名参数
print('{a1},{0},qqq {a2}'.format('aaaa',a1='bbbb',a2='cccc')) #混合参数(注意:后面替换的内容,位置参数必须在命名参数之前)
print('{a1},{0},qqq {a2}'.format(a1='bbbb','aaaa',a2='cccc')) #报错,因为位置错误
------------------------------
aaaa,bbbb,aaa cccc
aaa,bbb,qqq ccc
bbbb,aaaa,qqq cccc
5.4.3 内置函数format()
format()函数用于快速格式化单个字符串目标.(待补)
5.5 列表list([])
列表用于存放多个数据,也可以嵌套任意类型的数据,其元素的值可以是任意类型.
列表属于可变类型,可以修改某元素的值,不会开辟新的内存空间,各元素是有顺序位置的,可以通过索引取值,切片取子列表.
列表的索引和字符串一样,从0开始。注意的是，在列表只有一个元素的情况下，必须加多一个逗号，如 l=['a',] ，不加多一个逗号可能会被识别为字符串.
列表的定义方法:
s=[] #空列表
print(s)
s=list([]) #等价于上面
print(s)
l=[ #跨行写法
'a'
,1,
[1],
{'a':1}
]
print(l)
-------------------
[]
[]
['a', 1, [1], {'a': 1}]
更新列表内元素:
l=['a',1,'b',2,'c'] l[0]='A' #指定索引,更新对应的值 print(l) ------------------- ['A', 1, 'b', 2, 'c']
循环字符串造列表:
l=list('abcdef') #本质上就是一个for循环
print(l)
#等价于
l='abcdef'
l1=[]
for i in l:
l1.append(i)
print(l1)
---------------
['a', 'b', 'c', 'd', 'e', 'f']
['a', 'b', 'c', 'd', 'e', 'f']
5.5.1 列表的方法和内置函数
print(dir(list) #除了以下划线_开头的,主要还有以下几个 ------------- ['...', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
列表的方法:
列表的函数:
5.5.2 列表的常用操作符
5.5.3 列表按索引取值,切片,成员运算
列表属于可变类型,其元素按照索引顺序进行存储.既可以取,也可以更改,其id不会发生改变,但不可hash.
列表改值,不可超出索引的范围,超出范围取值会报错.
l=['a','b','c']
print(l[0],l[1],l[2]) #正向取值
print(l[-1]) #反向取值
l[0]='A' #更改元素的值
print(l)
l1=list('hello') #循环把字符串的子串造成一个列表
print(l1)
s=['tom','xx','www','qqq','aaa']
print(s[1:3],len(s)) #切片和长度
print(s[1:4:2]) #指定步长
print('xx' in s,'xxx' in s) #成员运算
---------------------------
a b c
c
['A', 'b', 'c']
['h', 'e', 'l', 'l', 'o']
['xx', 'www'] 5
['xx', 'qqq']
True False
5.5.4 往列表追加内容append()和插入内容insert()
append()和insert()都只能以一个元素为单位,进行追加或者插入,append()只能追加至最后, insert()可以指定索引插入,插入到索引前面的位置.
l=['a',1,'b','c',2]
print(id(l),type(l),l)
l.append('aaa') #只能以一个元素为单位追加至最后,同时追加多个元素会报错
print(id(l),type(l),l)
l.insert(0,'AAA') #指定索引位置,插入到前面
print(l)
--------------------------------
31194432 <class 'list'> ['a', 1, 'b', 'c', 2]
31194432 <class 'list'> ['a', 1, 'b', 'c', 2, 'aaa']
31194432 <class 'list'> ['AAA', 'a', 1, 'b', 'c', 2, 'aaa']
5.5.5 删除列表的元素del,pop()和remove()
万能删除法,删除列表某个元素,如 del list[0].
pop()删除:需指定索引值删除,如果不指定索引编号删除,默认删除末尾索引编号(即 -1).
remove()删除:只能指明删除的具体的某一元素,不支持索引.
pop()和remove()的区别是:pop()删除会返回删除的具体的元素值,而remove()删除则返回的是None.
l=['a',1,'b','c',2]
del l[0] #del删除法
print(l)
l=['a',1,'b','c',2]
print(l.pop(0)) #返回删除的元素值
print(l)
l=['a',1,'b','c',2]
print(l.remove('a')) #只能指明移除的具体的元素,并且返回为None
print(l)
-------------------
[1, 'b', 'c', 2]
a
[1, 'b', 'c', 2]
None
[1, 'b', 'c', 2]
5.5.6 列表其他方法
清空列表元素,变为空列表,使用clear() .
拷贝一个列表到新列表,使用copy().
统计列表某元素的个数,使用count().
同时添加多个元素至列表末尾,使用extend().
查找元素在列表中的位置(索引指向的位置,可以指定索引查找的范围),使用index().
将列表元素反转顺序显示,使用reverse().
l=['a',1,'b','c',2] #清空列表,使其变为空列表
l.clear()
print(l)
l=['a',1,'b','c',2] #拷贝一个列表
l1=l.copy()
print(l1)
l=['a',1,'b','c',2,'a'] #统计某元素在列表中的个数
print(l.count('a'))
l=['a',1,'b','c',2]
l.extend([3,'d',4]) #注意,同时添加多个元素添加必须使用[]括起来,本质上是列表的加法
print(l)
l=['a',1,'b','c',2]
print(l.index(2,0,5)) #查找元素的索引位置,可以指定查找的索引范围
l=['a',1,'b','c',2]
l.reverse() #
print(l) #反转显示
----------------------
[]
['a', 1, 'b', 'c', 2]
2
['a', 1, 'b', 'c', 2, 3, 'd', 4]
4
[2, 'c', 'b', 1, 'a']
5.5.7 列表的排序sort()和sorted()
sort()和sorted()可以用于列表排序,但sort()是原地排序,不会返回排序后的列表,而sorted()则是内置函数,会返回新的排序列表(需赋值给新变量).
python3.x中不支持数字和字符串混合排序,如果混合排序会报错,排序时,列表中元素必须是同一种类型,如,全字符串,或全数字.
l=['f','D','a','C','c','y','A'] #排序依赖ASCCI表,升序排序(A<B<...<Z<a<b<...<z) print(sorted(l)) #内置函数 l.sort() #方法 print(l) l=['f','D','a','C','c','y','A'] l.sort(reverse=True) #指定参数 reverse=True ,可以得到反序/降序 print(l) -------------------------------- ['A', 'C', 'D', 'a', 'c', 'f', 'y'] ['A', 'C', 'D', 'a', 'c', 'f', 'y'] ['y', 'f', 'c', 'a', 'D', 'C', 'A']
5.5.8 列表的循环取值
1)依赖索引取值
t=['a','b','c','d','e']
i=0
while i <len(t):
print(t[i])
i+=1
2)不依赖索引
t=['a','b','c','d','e']
for i in t:
print(i)
3)使用for循环切片,顾长不顾尾
t=['a','b','c','d','e']
for i in range(len(t)):
print(i,t[i])
------------------
0 a
1 b
2 c
3 d
4 e
4)使用for的enumerate(),既取索引,又去索引的值
t=['a','b','c','d','e']
for i in enumerate(t):
print(i)
--------------------
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(4, 'e')
--------------------
t=['a','b','c','d','e']
for x,y in enumerate(t):
print(x,y)
--------------------
0 a
1 b
2 c
3 d
4 e
5.5.9 列表的队列和堆栈
列表的队列:先进先出.
入队:往列表添加元素,使用append().
出队:取值,并返回取值的结果,使用pop().
t=[]
#入队
t.append('a') #append()以一个元素为单位,从左往右增加
t.append('b')
t.append('c')
print(t)
#出队
print(t.pop(0)) #取a,剩下b,c,并返回a
print(t.pop(0)) #取b,剩下c,并返回b
print(t.pop(0)) #取c,并返回c
print(t) #剩下空列表
---------------------
['a', 'b', 'c']
a
b
c
[]
列表的堆栈:先进后出.
t=[]
#入队
t.append('a')
t.append('b')
t.append('c')
print(t)
#出队
print(t.pop())
print(t.pop())
print(t.pop())
print(t)
----------------
c
b
a
[]
小结: list.pop([index=-1]),移除列表元素(默认从最后一个元素开始移除,索引值为-1),并且返回被移除的元素的值.
5.6 元组tuple(())
元组就是不可变的列表,使用()代替[],可以存多个值,有序有索引,属于不可变类型,可以使用hash()内置函数进行hash.
作用:元组主要需求是用来读,不可更改.元组存放的空间比列表小(在元素个数相同的情况下,使用元组更节省空间).
元组提供读的机制,其元素类型不能更改,但元组内元素有列表或字典嵌套,则内嵌的列表和字典内(value)的元素的值则是可变的.
定义:与列表类型相比,把[]换成(),其他的玩法和列表差不多,索引也是从0开始,元组中也可以嵌套任意类型的数据.
#元组的定义
t=(1,2,3)
print(id(t),type(t),t)
#等价于
t=tuple((4,5,6))
print(type(t),t)
#使用字符串创建元组
print(tuple('abcdef'))
#不可变
t=(1,2,3)
t[0]=11 #报错
print(t)
-----------------
7171904 <class 'tuple'> (1, 2, 3)
<class 'tuple'> (4, 5, 6)
('a', 'b', 'c', 'd', 'e', 'f')
TypeError: 'tuple' object does not support item assignment
注意:元组只包含一个元素时,必须在元素后面添加一个逗号,否则可能会导致创建的数据类型不准备,()可能会被当做运算符.
t=(); #创建空元组 print(type(t),t) t1=(50) #不加逗号,创建的数据类型是整型 print(type(t1),t1) t2=(50,) #加逗号,创建的数据类型为元组 print(type(t2),t2) ------------------------ <class 'tuple'> () <class 'int'> 50 <class 'tuple'> (50,)
元组当做字典的key
dic={(1,2,3):'aaa'}
print(dic[(1,2,3)])
--------------
aaa
5.6.1 元组的内置函数和方法
方法:
print(dir(tuple)) ---------------- ['...', 'count', 'index']
实例:
t=('a','b','c')
print(t.index('a')) #查看元素在索引中的位置
print(t.count('c')) #查看元素在元组中的数量
------------------
0
1
5.6.2 元组按照索引取值
元组属于不可变类型,值只可以取,不可以改,可以从索引正反向取值.
#从索引取值
t=('a',1,2)
i=0
while i < len(t):
print(t[i])
i+=1
#不依赖索引取值
t=('a',1,2)
for i in t:
print(i)
-----------------
a
1
2
5.6.3 元组运算符
元组属于不可变类型,意味着不可更改,删除,或重新赋值.但多个元组之间可以像字符串一样,使用加法和乘法,用+和*进行组合.
元组切片截取会生成一个新的元组(切片一律遵循顾头不顾尾的原则)
t=(1,2,3,4) print(id(t),t) t1=t[1:3] #顾头不顾尾 print(id(t1),type(t1),t1) ------------------- 39492400 (1, 2, 3, 4) 39596800 <class 'tuple'> (2, 3)
5.7 字典dict({})
字典是可变类型的容器,可以存储任意类型的对象,存储以key:value键值对的方式存储,不可hash(unhashable)
字典没有索引,不注重排序,即无序,每个key都对应了一个value值.(注意的是:key不可变,且大多数使用字符串类型,但value可以是任意类型)
用途:存多个值,存取都很快,缺点是浪费空间.
字典的key一般使用字符串,数字,元组3个不可变类型数据作为key,key常用字符串来表达一些描述性的信息,而使用数字作为key,则可能会被误当做索引.
字典的定义:使用{},元素用逗号分隔,存多个key:value(注意:key不可变,且不可重复,重复的话,后面的key对应的value值会覆盖掉前面的value值,最后只保留一个key:value键值对,即以最后的为准).
d={'a':'li','b':12,'c':'boy','d':'girl'}
print(id(d),type(d),d)
#等价于
d=dict({'a':'li','b':12,'c':'boy','d':'girl'})
print(id(d),type(d),d)
-------------------------
6965120 <class 'dict'> {'a': 'li', 'b': 12, 'c': 'boy', 'd': 'girl'}
32257728 <class 'dict'> {'a': 'li', 'b': 12, 'c': 'boy', 'd': 'girl'}
#使用多行定义字典
d={
'a':'li',
'b':12,
'c':'boy',
'd':'girl'
}
字典依赖key来取值,字典是按照key来存储的,通过key可以定位到元素所在位置.
d={'a':'li','b':12,'c':'boy','d':'girl'}
print(d['a'])
print(d['b'])
print(d['c'])
---------------------
li
12
boy
5.7.1 字典的内置函数和方法
内置方法:
5.7.2 字典中值的更改/添加/删除
更改/添加/删除/清空字典元素.
#更改
d={'a':'li','b':12,'c':'boy','d':'girl'}
d['a']='li10'
print(d)
d={'a':'li','b':12,'c':'boy','d':'girl'}
d['a']=d['a'].upper() #小写变大写
print(d)
#添加
d={'a':'li'}
d['b']=12;d['c']='boy' #注意使用的是分号链接
print(d)
#del删除
d={'a':'li','b':12,'c':'boy','d':'girl'}
del d['a'] #根据key删除,删除了就删除对应的value值
print(d)
#清空字典
d={'a':'li','b':12,'c':'boy','d':'girl'}
d.clear()
print(d) #变为空字典{},clear()清空字典所有元素
-------------------------------
{'a': 'li10', 'b': 12, 'c': 'boy', 'd': 'girl'}
{'a': 'LI', 'b': 12, 'c': 'boy', 'd': 'girl'}
{'a': 'li', 'b': 12, 'c': 'boy'}
{'b': 12, 'c': 'boy', 'd': 'girl'}
{}
5.7.3 字典其他
注意:使用pop(),如果字典没有对应的key,则会报错(此种情况下可以添加提示信息,如加多一个 None .
# 将小写变大写,li变为LI
d={'a':'li','b':12}
d['a']=d['a'].upper()
print(d)
# pop()取走值并返回,注意字典如果没有对应的key,会报错.为避免报错,最好加多一个None提示.
d={'a':'li','b':12}
d1=d.pop('a')
print(d1) #返回取走的值li
print(d) #此时只剩一个值'b':12
# keys取key值或多个key值,把字典的键都取出来,注意键不支持索引再次取键(不加keys默认也是取key)
d2={'a':'li','b':12,'c':'aaa','d':111}
print(list(d2.keys())[0])
for i in d2.keys(): #同时将所有的key打印出来
print(i)
# 只取value值
d2={'a':'li','b':12,'c':'aaa'}
print(d2.values()) #结果是特殊的形式,不是列表
# 分别取key和value值
d3={'a':'li','b':12,'c':'aaa'}
for k in d3.keys():
print(k)
for v in d3.values():
print(v)
# 使用items()取键值对,相当于循环dict_items([('a':10),('b':20)])
d4={'a':10,'b':20,'c':30}
print(d4.items()) #结果是特殊的形式
for x,y in d4.items():
print(x,y)
------------------------------
{'a': 'LI', 'b': 12}
li
{'b': 12}
a
a
b
c
d
dict_values(['li', 12, 'aaa'])
a
b
c
li
12
aaa
dict_items([('a', 10), ('b', 20), ('c', 30)])
a 10
b 20
c 30
长度len(),成员运算in和not in.
d={'a':10,'b':20,'c':30}
print(d.items())
for x,y in d.items():
print(x,y)
print(len(d)) #判断元素个数
print('a' in d) #in和not in基于key判断
print(10 in d)
--------------------
dict_items([('a', 10), ('b', 20), ('c', 30)])
a 10
b 20
c 30
3
True
False
其他示例:
# get() 取值，当key对应的值没有，则返回None
d={'a':10,'b':20,'c':30}
print(d.get('a')) #返回10
print(d.get('aaa')) #返回None
# popitem() 以元组的形式，随机返回一个键值对
print(d.popitem())
# update() 新字典更新旧字典（对于老字典来说，更新指：新字典中没有则添加；新字典有则覆盖）
d.update({'d':40,'a':1})
print(d)
# setdefault() 用处：字典有key，则不修改，并返回原key对应的原值；没有对应的key，则添加进字典，并返回新添加key对应的新值,视原字典是否有此键值对来决定。
d1={'name':'xiao','age':20,'sex':'man'}
d2=d1.setdefault('name','ABC')
print(d2) #有原key则返回其对应的值,返回的是setdefault()对应的值
d3=d1.setdefault('name1','ABC')
print(d3) #返回ABC,,并将其添加至新字典
print(d1)
# fromkeys() 用处：根据keys循环造值
print({}.fromkeys(['a','b','c'],None))
-----------------------------
10
None
('c', 30)
{'a': 1, 'b': 20, 'd': 40}
xiao
ABC
{'name': 'xiao', 'age': 20, 'sex': 'man', 'name1': 'ABC'}
{'a':None,'b':None,'c':None}
利用list或for循环取key键值:
d={'name':'aaa','age':18,'sex':'man'}
print(list(d.keys()))
print(list(d.keys())[0]) #利用list取key键值
#------------使用for循环取key
d={'name':'aaa','age':18,'sex':'man'}
for i in d.keys():
print(i)
5.7.4 字典重要且需要掌握的操作(某些重复)
# D.get() 根据key取value,如果没有对应的key,会返回结果None,不确定key是否在字典内,可以使用此种方式
d={'name':'aaa','age':18,'sex':'man'}
print(d.get('name'))
# D.popitem() 字典无序,以元组的形式随机返回一对键值对
d={'name':'aaa','age':18,'sex':'man'}
print(d.popitem())
# D.setdefault() 字典有key，则不修改，并返回原key对应的原值；没有对应的key，则添加进字典，
# 并返回新添加key对应的新值,视原字典是否有此键值对来决定。
print(d.setdefault('name','AAA')) #原字典有对应的key,则返回原值aaa
print(d.setdefault('name1','AAA')) #原字典没有对应的key,则添加至字典,name1键值对被添加至字典
print(d)
# D.fromkeys() 根据key循环造值(以下3个例子等价)
a={'a':None,'b':None,'c':None}
print(a)
#等价于
print({}.fromkeys(['a','b','c'],None))
#等价于
keys=['a','b','c']
d1={}
for key in keys:
d1[key]=None
print(d1)
-----------------------------------
aaa
('sex', 'man')
aaa
AAA
{'name': 'aaa', 'age': 18, 'name1': 'AAA'}
{'a': None, 'b': None, 'c': None}
{'a': None, 'b': None, 'c': None}
{'a': None, 'b': None, 'c': None}
setdefault()实例:
s='aa bb cc aa dd cc ee ff'
w=s.split()
d={}
for i in w:
d.setdefault(i,w.count(i))
print(d)
-----------------------------
{'aa': 2, 'bb': 1, 'cc': 2, 'dd': 1, 'ee': 1, 'ff': 1}
5.8 集合set({})
集合是可变类型的数据,但集合内的元素必须是不可变类型(意味着不可内嵌可变类型的数据,如列表,字典,集合).
集合用来进行关系运算,单独取集合的某一个元素是没有意义的,有没有相应的方法,使用for循环取值是无序的.
集合的用途:
1)集合是一个无序的不重复的元素的序列(重复的元素会被自动去重),无索引.
2) 集合一般用来当做一个整体,以整体为单位,与另一个整体做关系运算,如果仅仅是考虑集合的单个元素就没有多大意义.
集合的定义方式:
# 可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
s={'a',1,'b',2} #等价于
a=set({'a',1,'b',2})
print(id(a),type(a),a)
--------------
39761728 <class 'set'> {'b', 1, 2, 'a'}
利用集合去重示例:
a=[1,2,3,1,1,2]
b=set()
for i in a:
b.add(i)
print(b)
----------
{1, 2, 3}
5.8.1 集合的内置方法
5.8.2 2个集合的之间的运算(交集/差集/补集/并集等)
s1=set('abcdef') #利用字符串造集合
s2=set('asdb')
print(s1,s2)
# 使用 & 或函数 intersection() 取交集,以下2条命令等价
print(s1 & s2)
print(s1.intersection(s2))
# 使用 | 或函数 union() 取并集,将数据并在一起并去重,以下2条命令等价
print(s1 | s2)
print(s1.union(s2))
# 使用 - 或函数 difference() 取差集(去掉共同的元素,即集合s1包含,而s2不包含的元素),以下2条等价
print(s1 - s2)
print(s1.difference(s2))
# 使用 ^ 或函数 symmetric_difference() 取交叉补集(把2个集合合并在一起,去除共同的部分,取剩下的,以下2条等价)
print(s1 ^ s2)
print(s1.symmetric_difference(s2))
# 父集合(父集包含子集时比较才有意义,因为集合无序),而相等的情况下(=,<=,>=),互为父子集
s3={1,2,3}
s4={1,2}
print(s3 > s4) #返回True
print(s3 < s4) #返回False
# s5={1,2,4} #s5和s6比较没有意义,比较的结果返回的都是False
# s6={1,2,5}
------------------------------
{'a', 'e', 'b', 'f', 'd', 'c'} {'a', 'd', 's', 'b'}
{'a', 'd', 'b'}
{'a', 'd', 'b'}
{'a', 'e', 'b', 'f', 's', 'd', 'c'}
{'a', 'e', 'b', 'f', 's', 'd', 'c'}
{'e', 'f', 'c'}
{'e', 'f', 'c'}
{'e', 'f', 's', 'c'}
{'e', 'f', 's', 'c'}
True
False
其他示例:
s1={1,2,3}
s2={1,2}
print(s1.issuperset(s2)) #判断s1是否是s2的父集,返回True
print(s2.issubset(s1)) #判断s2是否是s1的子集,返回True
s1.difference_update(s2) #找出s1和s2的差集,并更新s1为差集的值
print(s1)
s2.add(3) #add() 往集合内添加元素,重复的不会添加(集合无序,无重复),一次只能添加一个值
print(s2)
s1.update({4,5,6}) #update() 添加并更新,去重,一次性可以添加多个值
print(s1) #注意上面s1={3}了
s2.discard(3) #discard() 从集合内删除元素,须指定删除的具体的元素,不是集合的成员不会删除,也不会报错
print(s2)
s2.remove(2) #remove() ,当删除的元素不存在,直接报错,而discard()则不会报错
print(s2)
s3=s1.pop() #随机(集合无序)取走一个元素并返回值
print(s3,s1)
# 2个集合,如果交集为空,即没有交集,则返回 True
s6={4,5,6}
s7={7,8,9}
print(s6.isdisjoint(s7))
print(s7.isdisjoint(s6))
-----------------------------------
True
True
{3}
{1, 2, 3}
{3, 4, 5, 6}
{1, 2}
{1}
3 {4, 5, 6}
True
True
5.8.3 集合元素的个数len(),成员运算,去重效果,循环取值
s1={1,2,3}
print(len(s1))
print(1 in s1)
print(4 not in s1)
-----------------
3
True
True
去重效果(循环造集合):
s=set('aabbcc') #无序,自动去重
print(s)
l=['a','b','a',1,1,'a'] #列表造集合
print(set(l))
l=['a','b','a',1,1,'a'] #列表利用集合去重
print(list(set(l)))
#循环造集合
l=['a','b','a',1,1,'a']
l_new=[]
s=set()
for i in l:
if i not in s:
s.add(i)
l_new.append(i)
print(s)
---------------------------
{'b', 'a', 'c'}
{'b', 1, 'a'}
['b', 1, 'a']
{'b', 1, 'a'}
集合循环取值:
s1={1,2,'a','b','c'}
for i in s1:
print(i) #无序,随机
------
1
2
a
c
b
5.9 布尔值类型bool()
布尔值，一个True一个False，在python中，bool的True和False是数值1和0的字符串表示格式，实际上bool类型是int类型的一个子类.
布尔值的主要作用:逻辑判断,判断一个条件是否成立,成立则用True标识,不成立则用False标识.
注意:
1)所有的数据类型自带bool值(通过比较可以得到)
2) None,0,0.0,空(空字符串(''),空列表[],空字典{},空元组,空集合等)这几种种情况下布尔值bool为False假,其余均为True真.
3)实际上，一个数据对象是真还是假，是根据这个类型的__bool__()的返回值(为False则为假,反之为真)以及__len__()的返回值(为0则为假)来决定的。
print(type(True)) print(bool.__bases__) --------------- <class 'bool'> (<class 'int'>,)
通过bool函数可以测试数据对象,表达式是否为True或False.
print(bool(0))
print(bool(None))
print(bool({}))
---------------
False
False
False
6 流程控制语句
6.1 pass,break,else,continue
以上4个关键字一般用于while和for循环中,其含义是:
break：退出当前层次循环(while/for)(如果嵌套了循环，则退出break所在的那个层次)
continue：直接跳到下一次循环
else：在循环正常退出(不是break中断的循环,即没有break)时执行的所执行的默认代码块
pass：在python中作为空的占位符，表示什么也不做。比如: if x:pass
while x:pass
def x():pass
class x:pass
6.2 if 条件控制语句
if 语句用来做判断控制，并选择要执行的语句分支，其语法格式如下：
1) elif 可选，可以有多个
2) else 可选，最多只有一个，可以没有
3) condition 条件表达式部分，以运算结果的True，False为if的分支执行依据，在python中所有的数据对象要么是True，要么是False（注意首字母大写），任意的数据和表达式都可以作为if语句的condition,注意condition部分只能是表达式,不能是语句,即condition部分不能包含赋值语句,如 if a = 1,这样是错误的.
if CONDITION1:
code_block(1)
elif CONDITION2: #<===可选，可以有多个
code_block(2)
elif CONDITION3:
...
...
else: #<===可选,可以没有
code_block_else
if中常用的操作运算符:
示例:
age=18
inp_age=int(input('猜猜你的年龄:')) #注意,input()是把所有的输入都转成字符串类型(python3.x)
if inp_age > age:
print('猜大了')
elif inp_age < age:
print('猜小了')
else:
print('猜对了')
if条件判断嵌套:
if 表达式1:
语句
if 表达式2:
语句
elif 表达式3:
语句
else:
语句
elif 表达式4:
语句
else:
语句
6.3 while循环
while+break:跳出本层循环.
while+continue:跳过本次循环,进入下一次循环.
while循环的结构形式:
while condition:
code
else: #可选,可以没有,使用while+else, else的代码块只有在while循环没有被break打断的情况下,才会有可能被执行(最后执行)
code
while+else实例(了解即可,极少使用):
count=1
while count < 6:
print(count)
count+=1
break
else: #打印完1-5就会执行else
print('else代码执行')
-----------------------
1
2
3
4
5
else代码执行
-----------------------
count=1
while count < 6:
print(count)
count+=1
break
else: #打印完1就停止,else不会执行
print('else代码执行')
-----------------------
1
6.4 for循环
在python中,for通常用于迭代循环,其语法结构如下:
for i in <Sequence>:
CODE
else:
CODE
for循环结合rang()函数,可以遍历数字序列,并支持步长(正向顾头不顾尾),如
for i in range(10):
print(i)
----------------
0
1
2
3
4
5
6
7
8
9
----------------
for i in range(0,5,2): #使用步长(顾头不顾尾)
print(i)
----------------
0
2
4
---------------
for i in range(5,0,-1): #反向步长(顾头不顾尾)
print(i)
---------------
5
4
3
2
1
for循环结合rang()和len()取索引及其对应的值:
t='asdfds'
for i in range(len(t)):
print(i,t[i])
------------------
0 a
1 s
2 d
3 f
4 d
5 s
