python中整数的默认书写格式_python学习之基本数据类型

一、基本数据类型

1、整形-int

2、字符串-str

3、布尔值-bool

4、列表-list

5、元组-tuple

6、字典-dict

二、整形数据类型——int

在python3中，整数类型的值不论有多大，都是属于int。

在python2中，整数类型的值在一定的范围内数据类型为int；超出了这个范围的数据类型为long长整形。

其实在java的数据类型中也是有int、long、short类型的划分，但是具体的划分标准没有深入的了解，等对python有了一定的了解后再回顾进行编辑。

1 a = 123

2 print(a)

1、int方法罗列

(1)、int.bit_length()：计算出该整形数以二进制表示出来需要使用多少位二进制——至少使用多少位二进制来进行表示

1 a = 123

2 #a_binary表示整型数a的二进制

3 #a_length 表示整型数a以二进制显示需要多少位二进制

4 a_binary =bin(a)5 a_length =a.bit_length()6 print(a, a_binary ,a_length)7 #运行结果为：123 0b1111011 7；其中a_binary的值0b111101中的0b表示以二进制表示

2、str：字符串类型转换为int：整型

1 a = "123"

2 #将字符串123转化为整型123

3 b =int(a)4 #从打印结果可以a：123为str类型

5 #b： 123为int类型

6 print(a,type(a))7 print(b,type(b))8 #打印结果为：123

9 #123

注：type()：可以输出值的数据类型；

3、字符串str转换为int(2)

1 a = "100111"

2 #如果直接书写为int(a)表示为默认以10进制的方式进行转换

3 a_10 =int(a)4 #base=2以二进制的方式进行转换

5 a_2 = int(a,base=2)6 #base=16以16进制的方式进行转换

7 a_16 = int(a,base=16)8 print(a_10,a_2,a_16)

三、字符串str

在str字符串的方法中如果参数=none表示该参数可有可无，不是必须要写入的参数

1、capitalize ：将字符串的首字符大写，其余字符小写；

用法：a.capitalize()

1 name = "tENgjiAng"

2 #将字符串的第一个字符大写，其余小写

3 a =name.capitalize()4 print(a)5 #输出结果如下：Tengjiang

2、casefold/lower：将字符串全部转换为小写

用法：b.casefold()　　b.lower()

1 name = "tENgjiAng"

2 b =name.casefold()3 #b = name.lower()

4 print(b)5 #输出结果：tengjiang

name = "tENgjiAng"

#将字符串的第一个字符大写，其余小写

b =name.lower()print(b)#输出结果：tengjiang

注：casefole与lower方法比较：

从代码执行的结果可以看出两方法结果是一致的，说明两者的功能是一样的；

区别：casefold方法更全面，很多未知的大小写对应关系都可以进行转换；

lower方法只能对通俗的英文大小写进行转换；

3、center：将字符串居中，指定参数可以指定长度内居中并将空白处用指定的字符填充

用法：a_center = a.center(20,"*")将字符串a在长度20的范围内居中，并用“*”号将空白处填充

1 #字符串a

2 a = "it's ends"

3 #在长度为20的字符串里面居中a字符串并用*号填充空白

4 a_center = a.center(20,"*")5 #a_center_len统计a_center的长度是否为20；

6 a_center_len = a_center.__len__()7 print(a_center,a_center_len)8 #输出结果：*****it's ends****** 20

注：从输出结果中可以看出当剩余的空白为偶数：两边填充的字符一样；

当剩余的空白为奇数时，左边填充少于到右边填充数

4、count：计算子字符串在字符串中出现的次数

使用方法：a.count("b"，5,6)计算字符b在字符串a中从第5到第6个字符中出现的次数

1 a = "chongbqing"

2 a_count = a.count("b",5,5)3 a_count1 = a.count("b",5,6)4 #输入串结果分别为：0 1

5 print(a_count,a_count1)6 #从结果中可以看出5、6是值的是字符串a的脚标

5、encode、decode

该方法还未学习到，暂时先搁置在这儿

6、endswith：判断是否字符串是否以子字符串结束，返回布尔值

使用方法：a.endswith("b")，也是可以写入其他参数的：开始位置，结束位置

a = "chongqing"a_endswith1= a.endswith("g")

a_endswith2= a.endswith("ing")

a_endswith3= a.endswith("q")print(a_endswith1,a_endswith2,a_endswith3)#输出结果为：True True False

7、startwith：判断字符串是否以子字符串、字符开始，返回布尔值

使用方法：a.startwith("b"),

代码同endswith，在此就不在贴码了

8、find：从首字符往后查找，找到第一个后，获取位置，不在继续查找；输出结果返回index，结果为-1表示在指定的位置没有找到

使用方法：a.find("substr",start,end)

1 a = "chongqing"

2 b = a.find("ing",4)3 b = a.find("ing",4,8)4 print(b)5 #输出结果为：6

6 #从结果可以看出参数缺省end参数,表示查找到字符串末尾；

9、format：格式化，将一个字符串的占位符替换为指定的值

1 a = "I am {name},{age},from {address}"

2 print(a)3 v = a.format(name="tengjiang",age=19,address="chongqing")4 #运行v1的时候报错了，提示keyerror：'address',说明format方法的占位符必须全部要一一对应

5 #v1 = a.format(name="tengjiang",age=19)

6 print(v)7 #输出结果：I am {name},{age},from {address}

8 #I am tengjiang,19,from chongqing

10、format_map：该方法没有搞懂，待搞懂了在回顾补充

11、index：与find功能一致，唯一的区别在于index找不到要报错，而find方法找不到返回的值为-1

1 a = "chongqing"

2 #我没有搞懂为什么b = a.index("ng",5,8)会报错；b1 = a.index("ng",5)我采用这种格式就能找到

3 #b = a.index("ng",5,8)

4 b1 = a.index("ng",5)5 b2 = a.index("ng")6 b3 = a.index("ng",4)7 #b4也是错误的，为什么呢，没搞懂，在builtins.py中index的格式也是start与end参数的

8 #原因排查：a、我格式是书写正确了的；

9 #原因排查：b、我的脚标是8是没有超出字符串a的脚标的最大长度的，因为在java中当数组的脚标超出了字符串脚标的最大长度时，是会报错的

10 #原因排查：c、在网上查询后，还是没有找到原因

11 #原因排查：d、将参数end=8换成a._len_()结果执行成功了

12 #原因排查：e、计算字符串a的长度确认是否等于8：b6 =a.__len__():输出结果为9，那说明字符串a的脚标最大为8是没有问题的啊

13 #b4= a.index("ng",5,8)

14 b6 =a.__len__()15 b5 = a.index("ng",4,a.__len

1 a = "123"

2 v =a.isalnum()3 print(v) #输出结果为：True

4 a = "sbd c"

5 v =a.isalnum()6 print(v) #False

__())16 print(b6)17 print(b1,b2,b3,b5)18 #输出的结果为：9 字符串a的长度

19 #输出的结果为：7 3 7 7

注：# b = a.index("ng",5,8)语句报错，还未解决!

####后期咨询验证，了解到a.index("ng",5,8)表示的范围为5<=index<8,是没有包含脚标8的；

12、isalnum：用来判断字符串是否全部为数字或者字母，返回布尔值；；如果有其他字符或者空格(返回false)

1 a = "sbd"

2 v =a.isalnum()3 print(v) #返回：True

4

5 #a = " teng "

6 ## print(a.isalnum()) #返回：False

13、isalpha：用来判断字符串是否由字母组成；返回布尔值

1 a = "adb"

2 v =a.isalpha()3 print(v) #返回True

4 #a = " adb"

5 #v = a.isalpha()

6 #print(v) #返回False

14、isdecimal：判断字符串是否为十进制的数字；

isdigit：判断字符串是否为十进制的数字，还可以判断特殊的数字编号如：②

isnumeric：判断是否为十进制的数字，可以判断特殊的数字编号：②，还可以判断中文的数字如：二、十

1 ######isdecimal#######

2 #a = "123"

3 #v1 = a.isdecimal() #返回True

4 #a = "②"

5 #v1 = a.isdecimal() #返回False

6 a = "二"

7 v1 = a.isdecimal() #返回False

8 print(v1)9 ########isdigit#######

10 a = "123"

11 v1 = a.isdigit() #返回True

12 #a = "②"

13 #v1 = a.isdigit() #返回True

14 #a = "二"

15 #v1 = a.isdigit() #返回False

16 print(v1)17 ########isnumeric#########

18

19 #a = "123"

20 #v1 = a.isnumeric() #返回True

21 #a = "②"

22 #v1 = a.isnumeric() #返回True

23 a = "二"

24 v1 = a.isnumeric() #返回True

25 print(v1)

15、isidentifier 判断是否为标识符

标识符：

在python里，标识符有字母、数字、下划线组成。

在python中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。

python中的标识符是区分大小写的。

以下划线开头的标识符是有特殊意义的。以单下划线开头(_foo)的代表不能直接访问的类属性，需通 过类提供的接口进行访问，不能用"from xxx import *"而导入；

以双下划线开头的(__foo)代表类的私有成员；以双下划线开头和结尾的(__foo__)代表python里 特殊方法专用的标识，如__init__()代表类的构造函数

1 a = "sum"

2 v =a.isidentifier()3 print(v) #输出True

16、islower：判断是否是小写

isupper：判断是否为大写

#a = "sum"#v = a.islower()#print(v) #输出True

a = "sum"v=a.isupper()print(v) #输出False

17、isprintable：判断打印时是否有不显示的字符

a = "abc\tefg\nmail"

print(a.isprintable()) #输出False

print(a) #输出 abc efg

#输出mail

18、isspace判断是否为空格

1 #a = " "

2 #print(a.isspace()) # 输出True

3 #a = "abc "

4 #print(a.isspace()) # 输出False

5 a = "a sbc"

6 print(a.isspace()) #输出False

19、istitle判断是否为标题

标题首字符全部大写

1 #a = "This Is An Apple"

2 #print(a.istitle()) #输出True

3 a = "This Is An apple"

4 print(a.istitle()) #输出False

20、join将字符串中的每个元素按照按照指定的分隔符进行拼接******

1 a = "别问我花儿是为谁红"

2 #a_join =" ".join(a)

3 #print(a_join) #输出：别 问 我 花 儿 是 为 谁 红

4 a_join1 = "_".join(a)5 print(a_join1) #输出：别_问_我_花_儿_是_为_谁_红

21、ljust：对字符串左边使用指定字符填充

rjust：对字符串右边使用指定字符串填充

zfill：指定0进行填充

center：

1 a = "python"

2 #v = a.center(20,"*") #输出：*******python*******

3 #v = a.ljust(20,"*") #输出：python**************

4 #v = a.rjust(20,"*") #输出：**************python

5 v = a.zfill(20) #输出：00000000000000python

6 #指定0进行填充，该方法不常用，因为center、ljust、rjust已经能够满足所有的填充要求

7 print(v)

22、lower：转换为小写

upper：转换为大写

#我们平时输入网址时输入大写和小写都是可以进行访问的，因为提交时就已经转换为小写了！

#在登录时，账号输入大小写也是可以进行登录，也是因为提交时进行转换了的，这种很少见！

23、strip：默认清除所有的空格；指定参数，去除指定参数、指定子字符串；

lstrip：默认清除左边的空格、\t、\n；指定参数，去除左边指定参数、指定子字符串；从左边开始找，找到第一个就不在继续查找去除；

rstrip：默认清除右边的空格、\n、\t；指定参数，去除右边指定参数、指定子字符串；从右边开始找，找到第一个就不在继续查找去除；

1 a1 = "pythonpy"

2 #print(a1.strip("py")) #输出结果为：thon

3 #print(a1.lstrip("py")) #ss输出结果为：thonpy

4 print(a1.rstrip("py")) #输出结果为：python

24、maketrans：创建对应关系，然后使用traslate进行替换

1 a = "pathon"

2 v = str.maketrans("a","y")3 new_v =a.translate(v)4 print(new_v) #输出：python

25、partition：按照指定字符进行分割：从左边往右边找到第一个指定字符然后分割；

rpartition：按照指定字符进行分割：从右边往左边找到第一个指定字符然后分割；

#两者都保留了指定分割符

1 a = "pathon_pycharm_day11"

2 #v = a.partition("_") #输出：('pathon', '_', 'pycharm_day11')

3 v = a.rpartition("_") #输出：('pathon_pycharm', '_', 'day11')

4 print(v)

26、split：按照指定分隔符分割，分割符去掉

rsplit：按照指定分隔符分割，分隔符去掉

ps：partiton与split功能的结合就是正则表达式的应用

1 a = "pathon_pycharm_day11"

2 #v = a.split("_") #输出：['pathon', 'pycharm', 'day11']

3

4 #"_"指定分隔符；1为从左边往右边找，找到第一个就停止继续查找

5 #v = a.split("_",1) #输出：['pathon', 'pycharm_day11']

6

7 #"_"指定分隔符；1为从右边往左边找，找到第一个就停止继续查找

8 #v = a.rsplit("_",1) #输出：['pathon_pycharm', 'day11']

9 v = a.rsplit("_",2) #输出：['pathon', 'pycharm', 'day11']

10 print(v,type(v))

splitlines：按照换行符进行分割

1 a = "username\npasswd\nmail"

2

3 #参数：True保留换行符

4 v = a.splitlines(True) #输出：['username\n', 'passwd\n', 'mail']

5

6 #参数：False不保留换行符

7 #v = a.splitlines(False) #输出：['username', 'passwd', 'mail']

8 print(v,a)

27、startswith：判断字符串是否以子字符串开头

endswith：判断字符串是否以子字符串结束

1 a = "python_pycharm"

2 #v = a.endswith("rm") #输出：True

3 v = a.startswith("py") #输出：True

4 print(v)

28、swapcase 大小写转换：大写转换为小写；小写转换为大写

a = "Python"v= a.swapcase() #输出：pYTHON

print(v)

29、expandtabs：分隔、断句，特殊适合用于断句

str_user_inform = "用户名\t密码\t邮箱\t电话\t备注\n张三\tzhangsan\tzhangsan@qq.com\t18502337951\t\n张三\tzhangsan\tzhangsan@qq.com\t18502337951\t\n张三\tzhangsan\tzhangsan@qq.com\t18502337951\t\n张三\tzhangsan\tzhangsan@qq.com\t18502337951\t\n"

v2 = str_user_inform.expandtabs(20)

print(v2)

输出结果

用户名 密码 邮箱 电话 备注

张三 zhangsan zhangsan@qq.com 18502337951

张三 zhangsan zhangsan@qq.com 18502337951

张三 zhangsan zhangsan@qq.com 18502337951

张三 zhangsan zhangsan@qq.com 18502337951

30、replace：替换原子字符串

name = "zhangsanlisiliwuzhaoli"

v = name.replace("li","si")

print(v)

name1 = "zhangsanlisiliwuzhaoli"

###第三个参数为替换多少次

v1 = name1.replace("li","si",2)

print(v1)

##输出结果：

zhangsansisisiwuzhaosi

zhangsansisisiwuzhaoli

*************************************************************

***************************************************

字符串Str方法小结

*************************************************************

*************************************************************

1、字符串方法中最常用的的方法

(1)、join    #指定字符连接

(2)、split   #指定分割符进行分割

(3)、find

(4)、strip

(5)、upper

(6)、lower

(7)、replace

2、字符串使用扩展

(1)、for循环

#for 变量名 in 字符串:#变量名#break#continue

#index = 0#while index < len(test):#v = test[index]#print(v)#

#index += 1#print('=======')

#for zjw in test:#print(zjw)

#test = "妹子有种冲我来"#for item in test:#print(item)#break

#for item in test:#continue#print(item)

(2)、通过索引获取字符串中的字符

1 #v = test[3]

2 #print(v)

(3)、切片

1 #v = test[0:-1]

2 #print(v)

(4)、len，获取字符串长度

#Python3： len获取当前字符串中由几个字符组成#v = len(test)#print(v)#在Python2：len获取当前字符串中有几个字节

(5)、range创建连续或者不连续的数字

1 #range创建连续的数字

2 v=range(100) #等价于range(0,100)

3 print(v)4 #在python3里面，不会立即创建，这是一个优化内存机制，只有在for循环的#时候才会打印

5 #在python2里面，会立即创建，占用大量内存

6 v=range(0,100,5) #按照步长打印

7 v=range(len(input()))

(6)、index,将索引与对应的值打印出来

1 #第一种

2 v = input("请输入你的理想，少年：")3 v_length = v.__len__()4 v_index =range(v_length)5 for i inv_index:6 print(i,v[i])7 #第二种

8 v = input("请输入你的理想，少年：")9 for i inrange(0,len(v))10 print(i,v[i])

3、关于字符串的误区

# 字符串一旦创建，不可修改

# 一旦修改或者拼接，都会造成重新生成字符串

1 name = "zhangsan"

2 age = "18"

3

4 info = name +age5 print(info)

四、列表、list

1、list：列表特点，li = [1,3,4,5,6,"list"]

(1)、中括号括起来

(2)、分割每个元素，逗号分割

(3)、列表中的元素可以是数字、字符串、列表、布尔值等，所有的数据类型都可以

(4)、列表是可以嵌套的，被嵌套的list算作一个元素

(5)、集合，内部可以放置任何类型的数据

(6)、可以通过索引取值，可以一层一层往下找；切片的结果也是列表；

(7)、可以进行迭代，循环：for  in、while循环

备注：a、对于字符串转换为列表：list(),内部使用的for循环；

b、数字是不能进行循环的；

c、列表转换为字符：列表中都是字符串可以通过join方法直接连接；列表中数字字符串，需要自己写for循环

1 s =""

2 for i inli:3 s = s+str(i)4 pritn(s)

(8)、列表的元素是可以进行修改的，也可以进行切片进行修改，

(9)、列表是有序的，存放元素的时候，每个元素后面保存有下一个元素的位置，类似于c语言中的链表

(10)、可以进行删除：del li[1]、切片方式删除：del li[1:3]

2、list方法

(1)、append：在原来的列表基础上追加元素

1 a = [11,22,33,444]2 v = a.append(555)3 print(v,a) #输出：None [11, 22, 33, 444, 555]

(2)、clear：清空列表

1 a = [11,22,33,444]2 a.clear()3 print(a)

(3)、copy：复制拷贝：浅拷贝

1 a = [11,22,33,444]2 v =a.copy()3 print(a,v)

(4)、count计算元素出现的次数

1 a = [11,22,33,444,22,444]2 v = a.count(44)3 print(v) #输出：0

(5)、extend：扩展原来的列表

备注：append与extend的区别：

1 a = [11,22,33,444,22,444]2 #当append的是list时，直接将追加的列表当做一个元素放入list中

3 #a.append([55,"python","pycharm"]) #输出：[11, 22, 33, 444, 22, 444, [55, 'python', 'pycharm']]

4

5 #当append一个字符串时，直接将字符串作为一个元素放入list中

6 a.append("zhangsan") #输出：[11, 22, 33, 444, 22, 444, 'zhangsan']

7 print(a)8

9 b = [11,22,33,444,22,444]10

11 #当extend的是list时，将列表中的每个元素作为元素放入list中

12 #b.extend([55,"python","pycharm"]) #输出：[11, 22, 33, 444, 22, 444, 55, 'python', 'pycharm']

13

14 #当extend的是字符串时，将字符串中的每个字符放入list中

15 b.extend("zhangsan") #输出：[11, 22, 33, 444, 22, 444, 'z', 'h', 'a', 'n', 'g', 's', 'a', 'n']

16 print(b)

(6)、index查找指定的值的索引，从左往右找，找到第一个后就不在继续查找

1 b = [11,22,33,444,22,444]2 print(b.index(22)) #输出：1

(7)、insert：指定索引位置插入元素

1 b = [11,22,33,444,22,444]2 b.insert(2,555)3 print(b) #输出：[11, 22, 555, 33, 444, 22, 444]

(8)、pop 默认删除最后一个元素，并获取删除的值；加入参数，删除指定索引的值

1 b = [11,22,33,444,22,444]2 #v = b.pop() #删除指定的值 输出：[11,22,33,444,22]

3 v = b.pop(1) #将index索引值为1的元素删除 输出：[11, 33, 444, 22, 444]

4 print(b)

(9)、remove：删除列表中的指定值，从左到右

1 b = [11,22,33,444,22,444]2 #v = b.remove(11) #输出：[22, 33, 444, 22, 444]，删除指定的值

3 v = b.remove(22) #输出：[11, 33, 444, 22, 444]，从左到右，删除找到的第一个值，不在继续查找

4 print(v,b)

(10)、reverse：将当前列表进行翻转

1 b = [11,22,33,444,22,444]2 b.reverse() #输出：[444, 22, 444, 33, 22, 11]

3 print(b)

(11)、sort：默认参数进行从小到大排序；sort(True)从大到小

1 b = [11,22,33,444,22,444]2 #b.sort() #输出：[11, 22, 22, 33, 444, 444]

3 b.sort(reverse=False)#输出：[11, 22, 22, 33, 444, 444]

4 #b.sort(reverse=True) #输出：[444, 444, 33, 22, 22, 11]

5 print(b)

五、元组：tuple

元组不可以被增加、删除、修改

1、tuple方法

(1)、count 统计元素出现在元组中的次数

a = (11,22,33,44,11,33,)print(a.count(11)) #输出：2

(2)、index获取指定元素在元组中的出现的次数

1 a = (11,22,33,44,11,33,)2 print(a.index(33) #查找到第一个后不再继续查找；输出：2

2、tuple扩展

(1)、书写格式：一般在最后一个元素中加入“，”，便于区分

tu = (111,"alex",(11,22),[(33,44)],True,33,44,)

(2)、索引：可以通过索引进行查找元素

(3)、可以进行切片

v = tu[0:2]

print(v)

(4)、可以被for循环，可以进行迭代

a = (11,22,33,44,11,33,)for item ina:print(item)

(5)、转换：元组、列表、字符串之间的转换

1 s = "asdfasdf0"

2 li = ["asdf","asdfasdf"]3 tu = ("asdf","asdf")4 #字符串转换为元组：将每个字符作为一个元素转换为元组

5 #v = tuple(s) # 输出：('a', 's', 'd', 'f', 'a', 's', 'd', 'f', '0')

6 #print(v)

7

8 #v = tuple(li) #输出：('asdf', 'asdfasdf')

9 #print(v)

10

11 #v = list(tu) #输出：['asdf', 'asdf']

12 #print(v)

13

14 #v = "_".join(tu) #输出：asdf_asdf

15 #v = "".join(tu) #输出：asdfasdf

16 #print(v)

(6)、扩展与追加

1 li = ["asdf","asdfasdf"]2 #li.extend((11,22,33,)) # ['asdf', 'asdfasdf', 11, 22, 33]

3 li.append((11.22,33)) #['asdf', 'asdfasdf', (11.22, 33)]

4 print(li)

(7)、元组中的一级元素不可被修改、删除、增加

1 tu = (111,"alex",(11,22),[(33,44)],True,33,44,)2 ## 元组，有序。

3 #v = tu[3][0][0] # 输出：33

4 #print(v)

5 v=tu[3]6 print(v) #输出[(33, 44)]

7 tu[3][0] = 567 #输出(111, 'alex', (11, 22), [567], True, 33, 44)

8 print(tu)

View Code

六、字典：dict

1、书写格式：

键值对；逗号分；使用{}进行括起；键与值用‘“：”进行对应

1 info ={2 "k1":"v1",3 "k2":"v2"

4 }5 print(info) #输出：{'k1': 'v1', 'k2': 'v2'}

2、字典中的value值可以是任意数据类型

1 info ={2 "k1": 18,3 "k2": True,4 "k3": [5 11,6 [],7 (),8 22,9 33,10 {11 'kk1': 'vv1',12 'kk2': 'vv2',13 'kk3': (11,22),14 }15 ],16 "k4": (11,22,33,44)17 }18 print(info)

View Code

3、字典中的key不能是列表、字典

1 info ={2

3 "k1": 'asdf',4 True: "123",5 #[11,22]: 123, #输出：unhashable type: 'list'

6 #(11,22): 123, 输出：unhashable type: 'dict'

7 {'k1':'v1'}: 123

8

9 }10 print(info)

View Code

4、字典是无序的

打印同一字典，字典里的元素顺序是变化的

5、可以通过索引方式找到指定元素

1 info ={2 "k1": 18,3 2: True,4 "k3": [5 11,6 [],7 (),8 22,9 33,10 {11 'kk1': 'vv1',12 'kk2': 'vv2',13 'kk3': (11,22),14 }15 ],16 "k4": (11,22,33,44)17 }18 #v = info['k1'] #输出：18，将key值为"k1"的value找到

19 #print(v)

20 #v = info[2] #输出：True,同上

21 #print(v)

22 v = info['k3'][5]['kk3'][0] #输出：11；

23 print(v)

View Code

6、字典支持删除：del info[key]

1 info ={2 "k1": 18,3 2: True,4 "k3": [5 11,6 [],7 (),8 22,9 33,10 {11 'kk1': 'vv1',12 'kk2': 'vv2',13 'kk3': (11,22),14 }15 ],16 "k4": (11,22,33,44)17 }18 #del info['k1']

19

20 del info['k3'][5]['kk1']21 print(info)

View Code

7、for循环

1 info ={2 "k1": 18,3 2: True,4 "k3": [5 11,6 [],7 (),8 22,9 33,10 {11 'kk1': 'vv1',12 'kk2': 'vv2',13 'kk3': (11,22),14 }15 ],16 "k4": (11,22,33,44)17 }18 #for item in info:

19 #print(item)

20 """输出结果：将key值循环打印21 k122 223 k324 k425

26 """

27

28 #for item in info.keys():

29 #print(item)

30 """输出结果：将key值循环打印31 k132 233 k334 k435

36 """

37 #for item in info.values():

38 #print(item)

39 """输出结果：将value值循环打印40 1841 True42 [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}]43 (11, 22, 33, 44)44 """

45 #for item in info.keys():

46 #print(item,info[item])

47 """输出结果：将key：value值成对打印出48 k1 1849 2 True50 k3 [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}]51 k4 (11, 22, 33, 44)52 """

53

54 #for k,v in info.items():

55 #print(k,v)

56 """输出结果：将key：value值成对打印出57 k1 1858 2 True59 k3 [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}]60 k4 (11, 22, 33, 44)61 """

62 #True 1 False 0

63 #info ={

64 #"k1": 'asdf',

65 #True: "123",

66 ## [11,22]: 123

67 #(11,22): 123,

68 ## {'k1':' v1'}: 123

69 #70 #}

71 #print(info)

View Code

七、布尔值：bool

布尔值比较简单，就不在罗列

八、数据类型整理

1 #一、数字

2 #int(..)

3 #二、字符串

4 #replace/find/join/strip/startswith/split/upper/lower/format

5 #tempalte = "i am {name}, age : {age}"

6 ## v = tempalte.format(name='alex',age=19)

7 #v = tempalte.format(**{"name": 'alex','age': 19})

8 #print(v)

9 #三、列表

10 #append、extend、insert

11 #索引、切片、循环

12 #四、元组

13 #忽略

14 #索引、切片、循环 以及元素不能被修改

15 #五、字典

16 #get/update/keys/values/items

17 #for,索引

18

19 #dic = {

20 #"k1": 'v1'

21 #}

22

23 #v = "k1" in dic

24 #print(v)

25

26 #v = "v1" in dic.values()

27 #print(v)

28 #六、布尔值

29 #0 1

30 #bool(...)

31 #None "" () [] {} 0 ==> False

View Code