基本数据类型
注意：数字，字符串，布尔值可以相互转换
如果需要把数字转换成 -字符串：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