基本数据类型
注意:数字,字符串,布尔值可以相互转换
如果需要把数字转换成 -字符串:str() ; -布尔值:bool(),只有0是False,其他都是True
字符串转换成-数字:int() ; -布尔值:bool(),空的是False,其他都是True
布尔值转换成-数字:int(); -字符串:str()
1, 数字 (int)
数字对应的英文是int(整型)
在python3 所有的整型都是int类型
查看具体功能可以按住ctrl(苹果:command) ,然后单击鼠标左键.
1) int 功能:
-将字符串转化为数字 具体表达为 int(x)
注意:原来的字符串内包含数字才可以转换
a = "123"
b = int(a)
print(b) ====>结果为123,
print(type(a),a)=====>输出结果为 <class "str">123 ,此处是字符串类型
print(type(b),b)=====>输出结果为 <class "int">123 ,此处是数字类型,
- 将二,八,十六进制 的数字转化成十进制并且输出。
具体代码: int(x,base=x),例如:
number = "11"
v = int (num , base=8) ======> 是指将八进制的11 转换成十进制并且输出
print(v)
输出结果是 9
int () 不加 base = ,默认是十进制
2)bit_lenght 功能
bit_length 功能表示当前的数字的二进制,至少用n位来表示.
具体代码为: x.bit_length() ,例如:
age = 12
n = age.bit_length()
print(n)
2,字符串(str)
str 与 name = "alisa" 是类与列表的关系。
字符串的英文是 str
查询有哪些功能 str.
查看具体功能可以按住ctrl(苹果:command) ,然后单击鼠标左键.
功能:
1)首字母大写 capitalize()
具体表达为x.capitalize() 如下:
test = "alisa"
v = test.capitalize()
print(v)
输出结果为:Alisa
2) 全部小写
casefold() **casefold 更牛逼,对于未知的相对应变小写也可以输出
具体代码为:x.casefold()
例如:
test = "Alisa"
v = test.casefold()
print(v)
输出结果为:alisa
*lower()
具体代码为:x.lower()
例如:
test = "Alisa"
v = test.lower()
print(v)
*3)全部大写upper()
代码为:x.upper()
test = "abc"
v1 = test.upper()
print(v1)===>结果为:ABC
4)设置宽度,
-并将内容并居中
center()
具体代码:X.center
查看功能具体如下图:
例如:
test = "lisa"
v = test.center(10,"*")
print(v)
输出结果为: ***lisa***
其中10代表宽度(必须写上),*代表空白未知填充,但是只能写一个字符,此处可有可无
-设置宽度,将内容居左 ljust()
代码:x.ljust()
test = "你好吗陈?"
v1 = test.rjust(12,"*")
print(v1)====结果为:你好吗陈?*******
-设置宽度,将内容具右rjust()
代码:x.rjust()
test = "你好吗陈?"
v1 = test.ljust(12,"*")
print(v1)====结果为:*******你好吗陈?
5) 去字符串中寻找,寻找子序列(子字符串)出现的次数。
count(self, sub, start=None, end=None): 注意:其中end代表的是 <end, start 代表>=start,位置从0位开始数
具体代码如下:x.count()
其中sub必须写上内容,start 和 end 可写可不写。 start 代表起始位置,end 代表结束位置。
例如:
test = "lisalisa"======>"lisalisa"对应的位置为:
01234567
v = test.count("sa",5,8) =======>指从第5位开始到第8位包含sa 几次===>第5位是i,第7位是a,到第7为完结===>所以包含sa一次,所以输出结果为1
print(v)====>输出结果为:1
6) encode(self, *args, **kwargs)
python3默认编码为unicode,由str类型进行表示。二进制数据使用byte类型表示。
字符串通过编码转换成字节码,字节码通过解码成为字符串
encode:str --> bytes
decode:bytes --> str
7)decode
*8) 以什么结尾。
endswith(self, suffix, start=None, end=None),注意:其中end代表的是 <end, start 代表>=start,位置从0位开始数
代码:x.endswith()
其中start 指从哪里开始,end指到哪里结束 (可写可不写,不写代表默认)
例如:
test = "lisalisa"
v = test.endswith("sa",1,4)
print(v) =========>结果是:True
****************************
test = "lisalisa"
v = test.endswith("sa",1,5)
print(v)==========>结果是:False
*9)以什么开始
startswith(self, prefix, start=None, end=None) 同上endswith 注意:其中end代表的是 <end, start 代表>=start,位置从0位开始数
代码: x.startswith()
test = "lisalisa"
v = test.startswith("i",1,2)==>指从第1位到第2位的子字符串(子序列)是以"i"开始的。
print(v)
输出结果为:True
10) 分割 字符串 expandtabs() ,遇到tab会自动空格补全 补充: ====>代表制表符
代码为:x.expandtabs()
expandtabs()代表几个字符串进行分割。例如:expandtabs(6) 代表6个字符分割成一个子字符串
例如:
test = "我的 9900 11"
v = test.expandtabs(6)====>每6个分割一次
print(v,len(v))========>len()是计算字符串的长度
输出结果为:我的 9900 11 14 ====>分析: 我的==2个,遇到 自动补全,所以补充4个空格。最终一共有14个字符
*****************************************************
test = "username password e-mail alisa 123 asd@qq.com alisa 123 asd@qq.com alisa 123 asd@qq.com"====> 表示换行
v = test.expandtabs(15)
print(v)
输出结果为:username password e-mail
alisa 123 asd@qq.com
alisa 123 asd@qq.com
alisa 123 asd@qq.com
*11) find 从开始往后找,找到第一个后,获取其位置,如果没有,显示-1
find(self, sub, start=None, end=None) 注意:其中end代表的是 <end, start 代表>=start,位置从0位开始数
代码:x.find(),如果找不到,会显示负数。
例如:
test = "lisalisa"
v = test.find("sa",2,4)===>即在第2位到第4位中间找子序列"sa"==>第2位是s,第4位是l,找到第一个获取的位置是2
print(v) ====>输出结果为: 2
*12)格式化。将一个字符串中的占位符替换成指定的值
format(self, *args, **kwargs)
代码为:x.format()
例如:
方式一:
test = "my name is {x}, age {n}"====>注意此处的x 和n必须带{}
v = test.format(x = "alisa", n = 18)
print(v)===>输出结果为:my name is alisa, age 18
方式二:
test = "my name is {0}, age {1}"====->注意必须从0开始
v = test.format("alisa", 18 ) ====> 注意按照顺序开始替换,此处alisa 替换0,18替换1
print(v) ==>输出结果为 my name is alisa, age 18
13)格式化。将一个字符串中的占位符替换成指定的值
format_map(self, mapping)
代码为:x.format_map() ,注意map后格式为({"a" : "alisa", "b" : 18})
例如:
test = "my name is {a}, age {b}"
v = test.format_map({"a" : "alisa", "b" : 18})===>注意格式
print(v)=====输出结果:my name is alisa, age 18
14)index 与find 功能一样,只是如果找不到会显示错误,一般建议使用find
15) 判断字符串中是否只包含字母和字符串/全是字母/全是字符串。
isalnum(self, *args, **kwargs)
代码为 x.isalnum()
例如:
test = "123abc"
v = test.isalnum()
print(v)===>输出结果为:True
***************************
test = "123abc_*"
v = test.isalnum()
print(v)====>输出结果为:False
16) 判断字符串中是否只包含字母(汉字)
isalpha(self, *args, **kwargs):
代码为:x.isalpha
例如:
test = "abc"
v = test.isalpha()
print(v) ===>输出结果为:True
***********************
test = "abc/"
v = test.isalpha()
print(v) ===>输出结果为:False
17)判断字符串是否只包含数字 isdecimal(),isdigit(),isnumeric()其中isnumeric()功能更强大
例如:
test = "123"
v1 = test.isdecimal()===>只能判断十进制小数
v2 = test.isdigit()===>不支持中文
v3 = test.isnumeric()===>全都可以判断
print(v1,v2,v3)
输出结果为:True True True
18)isidentifier()只要字符串符合:字母,数字,下划线(数字不能开头)就都是标识符 ,结果都是True。
例如:
test = "_123"
v = test.isidentifier()
print(v)
输出结果为:True
19)islower() 判断字符串是否全部是小写
test = "Abc"
v = test.islower()
print(v)
输出结果为:False
20)判断是否存在不可显示的字符 isprintable()
====>代表制表符即:tab键
====>代表换行
test = "Abc bcd"
v = test.isprintable()
print(v)===>结果为:False
*********************************
test = "Abc"
v = test.isprintable()
print(v)===>结果为True
21)判断是否全部为空格 isspace()
test = " "
v = test.isspace()
print(v)====>结果为:True
22) 判断是否为标题istitle() 代码是:x.istitle() 注意:标题中所有的单词首字母都大写
变成标题的代码是:x.title()
test = "who are you ?"
v1 = test.istitle()===>判断v1是否为标题
print(v1)====>结果是False
v2 = test.title()===>此处是将v1变成标题
print(v2)====>结果是:Who Are You ?
v3 = v2.istitle()===>判断v3是否为标题
print(v3)====>结果是True
*23)将字符中的每一个元素按照指定的分割符进行组合 join():即将每个元素用分隔符连接起来
代码:分隔符.join()
方式一:
test = "你好吗陈?"
v1 = "*".join(test)
print(v1)=======>结果为:你*好*吗*陈*?
方式二:
test = "你好吗陈?"
t = "*"
v1 = t.join(test)
print(v1)=====>结果为:你*好*吗*陈*?
如果join()括号内是列表的话,用分隔符依次连接列表中每一个元素:如下:
li = ["achnd", "hnd","sjnd"]
s = "-".join(li)
print(s)==>输出结果为:achnd-hnd-sjnd
----------------------------
l = ['1','2']
s= ' '.join(l) # 是换行符
print(s)
结果如下:
1
2
24)判断是否全部是大写 isupper()
代码为:x.isupper()
test = "abc"
v1 = test.isupper()
print(v1)====>结果是:False
*25)去除左右空白,去除 和 即:去除换行和制表符,以及去除指定字符。 注意:去除指定字符时会遵循有序最多匹配原则
-去除最左边和最右边空白 strip() 代码为:x.strip()
test = " 你 好 吗 "
v1 = test.strip()
print(v1)结果是:
你 好 吗
***********************
去除指定字符
test = "abcdfeg"
v1 = test.strip("acdeg")====>分析:strip是去除最左边以及最右边. 最右边有eg,所以去除,剩下abcdf,指定字符中没有f,所以右边停止去除。最左边有a所以也去除,剩下bcdf,由于指定字符中没有b,所以左边也停止去除,最后剩余bcdf.
print(v1)结果是:bcdf
-去除最左边空白lstrip()
test = " 你 好 吗 "
v1 = test.lstrip()
print(v1) 结果是:
你 好 吗
**********************************
去除指定字符
test = "abadafeg"
v1 = test.lstrip("abaf")====>分析:lstrip去除最左边,从左到右执行。从左边看最左边是aba,指定字符中有,所以去除aba,余dafeg;再从左看,指定字符中没有d,不去除;再看a,指定字符中有,所以去除a,余dafeg;由于字符串中也没d所以后边不执行,余dafeg.
print(v1)===>输出结果为dafeg
-去除最右边空白rstrip()
test = " 你 好 吗 "
v1 = test.rstrip()
print(v1)结果是:
你 好 吗
********************
去除指定字符
test = "abadafeg"
v1 = test.rstrip("egefa")==>从右往左执行,eg子字符串中有,去除eg;f,子字符串中有,去除f;a子字符串中有,去除a;d子字符串中无,停止执行,最后余abad.
print(v1)
结果为:abad
26) 对应关系并进行替换 maketrans(),translate()
maketrans("x","x") 其中("x","x") 是写对应关系。
例如:
test = "abadafegxkhuddaaebvmdnkdjiq"
x = test.maketrans("abcd","1234")===>对应关系
v =test.translate(x) ===>表示将test按照对应关系x进行转换
print(v)
结果为:12141fegxkhu4411e2vm4nk4jiq
27)分割
-进行分割并且只能分割成三份 partition(),从左到右进行分割,碰到第一个指定的分割元素就分割成三份,这三份中包含指定分割元素
代码:x.partition()
test = "absdfscds"
v = test.partition("s")
print(v)
结果为:('ab', 's', 'dfscds')
-rpsrtition() 从右边进行分割,碰到第一个指定的分割元素就分割成三份,这三份包含指定分割元素。
test = "absdfscdsd"
v = test.rpartition("s")
print(v)
结果是:('absdfscd', 's', 'd')
*-split(self, *args,**kwargs) ,可以分割成多份,多份里不出现分割元素。
*args处填写指定分割元素;**kwargs处填写分割几次,如果此处不写默认全部分割
test = "absdfscdsd"
v = test.split("s")
print(v)====>结果是['ab', 'df', 'cd', 'd']
******************************************
test = "absdfscdsd"
v = test.split("s",2)
print(v)====>结果是['ab', 'df', 'cdsd']
-rsplit() 从右往左分割成多份,不包含分割元素
test = "absdfscdsd"
v = test.rsplit("s",2)
print(v)===>结果是['absdf', 'cd', 'd']
-splitlines() 只能根据换行来分割,其中输入True / False 来保留/去除换行符号。如果不写,默认不保留换行符。注意True / False 首字母一定要大写
test = "absd fscdsd sdhgf"
v = test.splitlines()
print(v)====>['absd', 'fscdsd', 'sdhgf']
***********************************
test = "absd fscdsd sdhgf"
v = test.splitlines(True)========>True 保留换行符
print(v)=====>['absd ', 'fscdsd ', 'sdhgf']
27)大小写转换swapcase()
test = "Alise"
v = test.swapcase()
print(v)====>结果是:aLISE
28) zfill(宽度),原字符串靠右,左边剩余用0补齐
test = "Alisa"
v = test.zfill(12)
print(v)结果是:
0000000Alisa
*29)replace(old, new, count) 替换.
其中old是指原来的字符元素;new是指新的字符元素;count 是指替换几个,如果count 不写,默认全部替换
-全部替换,count不写。例如:
test = "alisaalisaalisaalisa"
v = test.replace("sa","xx")
print(v)=====>结果为:alixxalixxalixxalixx
-count 写具体数字。例如:
test = "alisaalisaalisaalisa"
v = test.replace("sa","xx",2)
print(v)=====>结果为:alixxalixxalisaalisa
灰魔法
*1) [] 索引 索引/下标:alisa
-通过索引/下标来获取字符串中的某一个字符。代码:x[],其中中括号中输入的是索引/下标 01234
test = "Alisa"
v = test[0]====>取变量test位置是0的索引内容
print(v)====>结果是:A
-获取切片 代码: x[x:x]
test = "Alisa"
v = test[0:-1]===>[0:-1]是大于等于0,小于-1。-1代表的是最后一个字符元素。
print(v)====>结果是:Alis
*2)len 查看当前字符串有多少个字符
test = "Alisa"
v = len(test)
print(v)
结果是:5
*3)for 循环,将对象中每个元素都进行循环
代码: for 变量名 in 字符串 :
print()====>此处是操作,任何其他操作都可以。
test = "Alisa"
for xc in test: ===>xc是自己设置的变量名
print(xc)
结果是:
A
l
i
s
a
注意:len(),索引,切片,for循环在几乎所有的数据类型都可以使用
字符串一旦创建就不可修改,一旦修改或者拼接,就会重新生成字符串
只要能被for进行循环获取,就是可迭代对象。
*4)range
-帮助创建连续数字。
test = range(100)
print(test)===>结果是:range(0, 100)
*************************************
test = range(100)===>输出内容小于100
for v in test:
print(v)
结果是:0
1
……
99
-按照步长设置不连续数字
test = range(0,100,5)===>0,100是指数字范围>=0,<=100,5是步长
for v in test:
print(v)
结果是:0
5
10
……
95
练习题
1,将输入的文字对应的索引打印出来
-使用for循环
test = input("请输入:")
print(test) ====>首先显示输入内容
l = len(test)
print(l) =====>查看输入内容的长度
===>然后需要在0-l的范围内循环
for t in range(0, l)
print(t, test[t])
简化后代码为:
test = input("请输入:")
for t in range(0, len(test)):
print(t, test[t])
结果为:
请输入:wode
0 w
1 o
2 d
3 e
-使用while循环
test = input("请输入")
count = 0
while count < len(test):
print(count, test[count])
count += 1
2,实现整数加法计算 例如:5+9 /5 +9/5+ 9
content = input("请输入内容:")
v1, v2 = content.split("+")=====>按“+”进行分割,分割完成后得到的是字符串。
v1 = int(v1.strip()) =====>字符串转换成数字
v2 = int(v2.strip())
s =v1 + v2
print(s)
3,计算用户输入内容有几个十进制小数,几个字母。
content = input("请输入内容")
number = 0
count = 0
for item in content:
if item.isnumeric() == True: =====>判断元素是否是数字
number += 1
elif item.isalpha() == True: =======>判断元素是否为字母
count += 1
print(number, count)
4,计算用户输入验证码,不区分大小写
while True:
while True:
code = check_code()
print(code)
inp = input("请输入验证码")
if inp.lower() == code.lower():====>两边同样是大写或者小写,就是表示不区分大小写
print("验证码输入成功")
break
else:
print("请重新输入")
5,在开发敏感词过滤程序,提示用户输入内容,如果输入内容包含特殊的字符如:“苍老师”,“东京热”,则将内容替换为***
li = ["苍老师","东京热"]====>列表
inp = input("请输入")
for item in li:
if item in inp:
inp = inp.replace(item,"***")
print(inp)
6,请使用代码实现:
li =["alex","eric","rain"] 利用下划线将列表的每一个元素拼接成字符串“alex_eric_rain"
v = "_".join(li)
print(v)====> 结果是:alex_eric_rain
7,制作趣味模版
需求:等待用户输入名字,地点,爱好,根据用户名字和爱好进行任意实现 如:敬爱可亲的xxx,最喜欢在xxx地方干xxx
hobby = “敬爱可亲的{0},最喜欢在{1}干{2}"
new = hobby.format("alisa","home","sleepping")
print(new)
8,制作表格
循环提示用户输入:用户名,密码,邮箱(要求用户输入长度不超过20个字符,如果超过则只有前20个字符有效)如果用户输入q或者Q表示不再继续输入,将用户输入的内容以表格形式打印
s = ""
while True:
v1 = input("请输入用户名")
v2 = input("请输入密码")
v3 = input("请输入邮箱")
mo = "{0} , {1} , {2} "
v = mo.format(v1, v2, v3)
s = s + v
if v1.lower() == "q":
break
print(s.expandtabs(20))
3,列表(list) 类
列表是有序的,元素是可以被修改的
灰魔法
对象:li = [xx,xx,xx]
-中括号括起来,
-中间以,分割每个元素
-可以嵌套任何类型。
-列表中元素可以是字符串,数字,列表,布尔值
-可以通过索引/切片取值
li =[12,34,56]
print(li[0])===>结果是12,索引取值
********************************
列表中嵌套列表,取嵌套列表中的元素。代码是:列表[嵌套列表所在元素的索引][嵌套列表索引][嵌套列表中元素所在索引]
li = [12, 34, [45, [29, 31], 67], 56]
需要取出29,代码如下:
v = li[2][1][0] =====>先写所在元素索引[2],然后写元素中嵌套的列表的索引[1],最后写值的索引[0]
print(v)======>结果是29,索引取值
****************
li =[12,34,56]
print(li[0:2])===切片取值,结果是[12, 34]
-for 循环
li =[12, 34, [45, 67], 56]
for item in li:
print(item)
结果是:
12
34
[45, 67]
56
-列表元素可以被修改,修改列表中元素:
注意:如果需要修改的列表元素是字符串,则不能用索引/切片直接赋值修改。ps:因为字符串一旦创建不可修改。
1)通过索引进行修改
首先用索引找到要修改的元素如li[x],然后直接赋值代码是:li[x] = ?
li =[12, 34, [45, 67], 56]
li[1] = 20
print(li)====>结果是:[12, 20, [45, 67], 56]
2)通过切片进行修改
首先先找到要修改的元素切片如li[1, 3],然后直接赋值修改代码是:li[x:x] = [?, ?]
li = [12, 34, [45, 67], 56]
li[1:3] = [20, 23]
print(li)=====>结果是:[12, 20, 23, 56]
-列表元素可以被删除。删除代码如下:
1)del 代码:del 索引 / del 切片
li =[12, 34, [45, 67], 56]
del li[1]====>删除列表li中的索引是1的元素(34)
print(li)=====>结果是:[12, [45, 67], 56]
*******************************************
li = [12, 34, [45, 67], 56]
del li[1:3]
print(li)======>结果是:[12, 56]
2) pop 删除列表某个值,并获取删除的这个值
代码:x.pop(索引位置),若索引位置不写,默认是删除最后一个元素。
li = [ 21, 34, 21, [21, 23]]
v = li.pop()
print(li)====>结果是:[21, 34, 21]
print(v)=====>结果是:[21, 23]
*********************************************************
li = [ 21, 34, 21, [21, 23]]
v = li.pop(1)
print(li)======>结果是:[21, 21, [21, 23]]
print(v)=======>结果是:34
3)remove 删除列表中的指定值,从左开始找到并删除,后边不执行(左边优先)
代码:x.remove(值)
li = [ 21, 34, 21, [21, 23]]
li.remove(21)=====从左开始,第一个就是21,直接删除然后不往下执行。
print(li)=====>结果是:[34, 21, [21, 23]]
4)clear 清空
代码:x.clear()
li = ["wode", '我们']
li.clear()
print(li)====>结果是:[]
-支持in操作 ,判断是否是列表中的元素
判断是否在列表里边(指元素),即是否是列表中的元素。
li = [12, 34, [45, 67], 56]
v = 34 in li
print(v)=====>结果是:True
***********************
li = [12, 34, [45, 67], 56]
v = 67 in li====>判断67是否是列表中的元素,由于[45, 67]才是li里的一个元素,所以67不是列表的元素
print(v)======>结果是:False
- 字符串转换成列表 代码是:list(字符串)
a = "sdhfg"
a1 = list(a)
print(a1)=======>结果是:['s', 'd', 'h', 'f', 'g']
-列表转换成字符串
1)如果列表里既有数字又有字符串,需要自己写for循环一个一个处理。如下:
li =[12, 34, "wode", '我们']
s = ""
for v in li:
s = s + str(v)
print(s)====>结果是:1234wode我们
2)如果列表只有字符串,可以使用代码:"".join()
li = ["wode", '我们']
a = "".join(li)
print(a)====>结果是:wode我们
-数字不能转换成列表
-enumerate(列表/字典/元祖,序号从几开始) 给可迭代对象添加序号
如下:
li = (12, 22, 33, 44)
for k, v in enumerate(li, 1):
print(k, v)====>1 12
2 22
3 33
4 44
list类中提供的方法
对象调用某个方法:对象.某个方法(....)。
例如对象:列表li, 方法append, li.append()就是li对象调用了append方法。
*1)append(self, *args, **kwargs) 在原来列表最后追加参数(整个元素)
代码:x.append(a) 其中 (a)称为参数
li = ["wode", '我们']
li.append([1234])=====>由于列表可以修改,所以可以直接操作,[1234]作为一个元素直接添加在列表最后。
print(li)====>结果是:['wode', '我们', [1234]]
2)clear 清空
代码:x.clear()
li = ["wode", '我们']
li.clear()
print(li)====>结果是:[]
3)copy 拷贝(浅拷贝)
代码:x.copy()
li = ["wode", '我们']
v = li.copy()
print(v)====>['wode', '我们']
4) count 计算元素出现的次数
代码:x.count()
li = ["wode", '我们', 21, 34, [21, 23]]
v = li.count(21)=====>元素21只出现一次,[21, 23]中的21 不计算,因为它不是列表的一个元素。
print(v)====>结果是:1
*5)extend 扩展原列表。参数:可迭代对象
代码:x.extend(可迭代对象)
li = [21, 34, [21, 23]]
li.extend("我不高兴")
print(li)======>结果是:[21, 34, [21, 23], '我', '不', '高', '兴']
6) index 根据值查找当前值所在列表中的索引位置,从左到右找,找到第一个直接输出索引位置,后边不执行
li = [21, 34, 21, [21, 23]]
v = li.index(21)
print(v)=====结果是:0
7)insert 在指定索引位置前插入
代码:x.insert(索引,插入内容)====>插入位置在索引前
li = [21, 34, 21, [21, 23]]
li.insert(2,["我们", 12])====>在索引2前边添加["我们", 12],即是在元素21前边添加["我们", 12]
print(li)=====>结果是:[21, 34, ['我们', 12], 21, [21, 23]]
8) pop 删除列表某个值,并获取删除的这个值
代码:x.pop(索引位置),若索引位置不写,默认是删除最后一个元素。
li = [21, 34, 21, [21, 23]]
v = li.pop()
print(li)====>结果是:[21, 34, 21]
print(v)=====>结果是:[21, 23]
*********************************************************
li = [21, 34, 21, [21, 23]]
v = li.pop(1)
print(li)======>结果是:[21, 21, [21, 23]]
print(v)=======>结果是:34
9)remove 删除列表中的指定值,从左开始找到并删除,后边不执行(左边优先)
代码:x.remove(值)
li = [21, 34, 21, [21, 23]]
li.remove(21)=====从左开始,第一个就是21,直接删除然后不往下执行。
print(li)=====>结果是:[34, 21, [21, 23]]
10)reverse 将列表中的元素反转。
代码:x.reverse()
li = [21, 34, 21, [21, 23]]
li.reverse()
print(li)=======>[[21, 23], 21, 34, 21]
11)sort 给列表中的元素按照一定的顺序排序
代码:x.sort(顺序)
1,元素从小到大排序代码: x.sort()
li = [21, 34, 21, 56]
li.sort()
print(li)=====>结果是:[21, 21, 34, 56]
2, 元素从大到小排序代码:x.sort(reverse=True)
li = [21, 34, 21, 56]
li.sort(reverse=True)
print(li)======>结果是:[56, 34, 21, 21]
3, cmp
4, key
5,sorted
4,元祖(tuple)
元祖基本操作
列表有序,元素可以被修改
li = [11, 22, 33, 44]
1,元祖的一级元素不可以被修改,并且元组不可以被增加或者删除。ps:推荐:书写元祖时在最后一个元素后加上逗号,
tu = (11, 22, 33, 44,)
2,元祖可以通过索引/切片取值
tu = (11, 22, 33, 44,)
v1 = tu[0]======>通过索引取值,结果是:11
v2 = tu[0:3]=====>通过切片取值,结果是:(11, 22, 33)
print(v1,v2)
3,可以被for 循环,是可迭代对象
tu = (11, 22, 33, 44,)
for item in tu:
print(item)
结果是:
11
22
33
44
4,字符串,列表,元祖 相互转换
-字符串转换成元祖 tuple(字符串)
s = "asddef234"
s2 = tuple(s)
print(s2)===>结果是('a', 's', 'd', 'd', 'e', 'f', '2', '3', '4')
-列表转换成元祖 tuple(列表)
li = [45, 32, "sdf"]
li1 = tuple(li)
print(li1)====>结果是:(45, 32, 'sdf')
-元祖转换成字符串
1)如果元祖中元素都是字符串可以使用join 方法 代码:"".join(元祖)
tu = ("sde", "ed",)
v = "".join(tu)
print(v)===>结果是:sdeed
2)如果元祖中元素既有字符串也有数字,代码如下:
tu = ("sde", "ed", 123,)
s = ""
for item in tu:
s = s +str(item)
print(s)====>结果是:sdeed123
-元祖转换成列表 list(元祖)
tu = ("sde", "ed", 123,)
v = list(tu)
print(v)====>结果是:['sde', 'ed', 123]
5,元祖也是有序的,元祖取值 如下:
tu = (111, "alex",[(22, 33,)])
取出22 代码如下:
v = tu[2][0][0]
print(v)===>结果是:22
6,元祖的一级元素不可修改/删除/增加,但是其中的列表可以修改。
tu = (111, "alex",[(22, 33,)])=====>(22, 33,)中的22 不可修改因为它是元祖(22, 33,)的一级元素
tu[2][0] = 12
print(tu)====>结果是:(111, 'alex', [12])
解析:
tu[2][0]取出来的是(22, 33,),它不是列表的一级元素
(22, 33,)是在列表中的,而列表可以修改的,所以就可以修改为12
7,方法
-count,指定元素在元祖里出现的次数
代码:元祖.count(元素)
-index 指定元素的索引
代码:元祖.index()
5,字典(dict)
-格式:{key: value},
-value 可以是任何类型:字符串,布尔值,元祖,数字,字典,列表等等
-列表,字典不能作为字典的key,其他都可以
1)当True/False 作为key 时 并字典内有key 是1/0时,True/False 会与1/0重复,只会显示一个.
ps:True(0) False(1)
infor = {"a1":"b1", 1: {"c4":[55, 38], 5: 8}, True: (12, [22, 33],)}
print(infor)========>{'a1': 'b1', 1: (12, [22, 33])}
2)当True/False 作为key 时 并字典没有key 是1/0时,会显示True
infor = {"a1":"b1", 3: {"c4":[55, 38], 5: 8}, True: (12, [22, 33],)}
print(infor)==========>{'a1': 'b1', 3: {'c4': [55, 38], 5: 8}, True: (12, [22, 33])}
info = {"a1": "b1", "a2": "b2"}. 元素"a1" : "b1"是键值对,"a2" : "b2"也是,其中b1,b2 是字典里的value;a1,a2是key.
-字典无顺序,所以没有切片,只能索引
-字典取值
代码:字典[key]
infor = {"a1": "b1", 3: "c1"}
v = infor["a1"]
print(v)====>结果是:b1
注意:如果字典内value嵌套元祖/列表时,要取嵌套元祖/列表内的值 代码:字典[key] [元祖/列表索引] [值索引]
如果字典内value 嵌套字典时,要取嵌套字典内的值 代码:字典[key] [嵌套字典的key]
infor = {"a1": "b1", 3: {"c4": [55, 38]}, 5: (12, [22, 33],)}
v1 = infor[5][1][0]
print(v1)=========>结果是:22
v2 = infor[3]["c4"][0]
print(v2)=========>结果是:55
-del 删除字典内元素
代码:del 字典[key]
删除[55, 38]
infor = {"a1": "b1", 3: {"c4":[55, 38], 5: 8}, 5: (12, [22, 33],)}
del infor[3]["c4"]
print(infor)=======>结果是:{'a1': 'b1', 3: {5: 8}, 5: (12, [22, 33])}
-for 循环
for 循环默认只输出key 代码: for 变量 in 字典:
print(变量)
infor = {"a1": "b1", 3: {"c4":[55, 38], 5: 8}, 5: (12, [22, 33],)}
for item in infor :
print(item)========>结果是:a1
3
5
ps:另外输出key还有另一个代码:for 变量 in 字典.keys:
print (变量)
infor = {"a1": "b1", 3: {"c4":[55, 38], 5: 8}, 5: (12, [22, 33],)}
for item in infor.keys() :
print(item)=======>结果是:a1
3
5
如果只需要输出value ,代码: for 变量 in 字典.values():
print (变量)
如果既要获得key,又要获得value
1)代码:
for 变量 in 字典:
print (变量, 字典[变量])
infor = {"a1": "b1", 3: {"c4":[55, 38], 5: 8}, 5: (12, [22, 33],)}
for item in infor:
print(item, infor[item])===>结果是:a1 b1
3 {'c4': [55, 38], 5: 8}
5 (12, [22, 33])
2) 代码:
for k, v in 字典.items(): ======>k, v 是键值对变量
print(k, v)
infor = {"a1": "b1", 3: {"c4":[55, 38], 5: 8}, 5: (12, [22, 33],)}
for k, v in infor.items():
print(k, v)======>结果是:a1 b1
3 {'c4': [55, 38], 5: 8}
5 (12, [22, 33])
-功能
1)clear 清空字典
2)copy 浅拷贝
3)fromkeys 根据序列,创建字典,并指定统一的值 .代码:dict.fromkeys(列表,value)
fromkeys 支持直接写类名执行这个功能。
v = dict.fromkeys(["wode", 23], 54)
print(v)======>结果是:{'wode': 54, 23: 54}
4)get : 根据key 取值,如果key 不存在,可以指定默认值(默认None);如果key存在,直接输出key对应的value 值
代码:字典.get(key, 设置默认值),默认值不写,默认None
dic = {12: "wo", 34: 56}
v = dic.get(22)
print(v)=====>结果是:None
**************************
dic = {12: "wo", 34: 56}
v = dic.get(22,"不存在")
print(v)=====>结果是:不存在
v2 = dic.get(12,"不存在")
print(v2)======>结果是:wo
*5)items 运用在for 循环中,获取key以及其对应的value
代码:
for k, v in 字典.items():
print(k, v)
dic = {12: "wo", 34: 56}
for k, v in dic.items():
print(k, v)===结果是:
12 wo
34 56
*6)keys 只获取字典中所有的keys
代码:
for x in 字典.keys():
print(x)
dic = {12: "wo", 34: 56}
for x in dic.keys():
print(x)====>结果是:
12
34
*7)values 只获取字典中的values
代码:
for x in 字典.values():
print(x)
dic = {'k1': "wo", 'v2': 56}
for x in dic.values():
print(x)===>结果是:wo
56
8) pop 根据key,删除指定键值对,并获取删除的键值对中的value值
代码:字典.pop(删除指定key,设定值) ps:设定值可写可不写。如果写上,一旦指定的key不存在字典中,可以输出设定值
dic = {12: "wo", 34: 56, 22: "nide"}
v = dic.pop(12)
print(dic)====>结果是:{34: 56, 22: 'nide'}
print(v)======>结果是:wo
*********************************************
dic = {12: "wo", 34: 56, 22: "nide"}
v = dic.pop(33, "不存在")
print(v)======>结果是:不存在
9)popitem() 随机删除键值对并输出键值对
代码:字典.popitem() /或者k, v = 字典.popitem()
dic = {12: "wo", 34: 56, 22: "nide"}
v = dic.popitem()
print(v)=====>结果是:(22, 'nide')
************************************
dic = {12: "wo", 34: 56, 22: "nide"}
k, v = dic.popitem()
print(k, v)======>结果是:22 nide
10)setdefault 设置值,代码:字典.setdefault(设置的key, 设置value)
-如果设置的key在字典中存在,不设置,并获取当前key在字典中对应的value
dic = {12: "wo", 34: 56}
v = dic.setdefault(12, "在吗")
print(dic)=====>结果是:{12: 'wo', 34: 56}
print(v)=======>结果是:wo
-如果设置的key在字典中不存在,设置,并获取设置value
dic = {12: "wo", 34: 56}
v = dic.setdefault("你好", "在吗")
print(dic)======>结果是:{12: 'wo', 34: 56, '你好': '在吗'}
print(v)=====>结果是:在吗
*11) update 更新字典中的键值对,如果字典中包含更新的key,直接将原value 更新成新value;如果字典中不包含更新的key,直接把键值对添加进字典中。有两种方式如下:
-代码:字典.update({更新的key: 更新的value})
dic = {12: "wo", 34: 56}
dic.update({12: 11, 33: 55})
print(dic)==========>{12: 11, 34: 56, 33: 55}
-代码: 字典.update(更新的key=更新的value)
dic = {'k1': "wo", 'v2': 56}
dic.update(k1 = 22, v3 = 456)
print(dic)=====>结果是:{'k1': 22, 'v2': 56, 'v3': 456}
6,布尔值(bool)
以下结果都是False:
None "" () [] {} 0