python基础数据类型： int bool str list tuple dict

Posted 2021-01-17 北边的大鱼

一.  int

 bit_length()        计算十进制转化成二进制的有效位数

1 v = 11
2 data = v.bit_length()
3 print(data)

View Code

二.  bool

布尔值就两种：True，False。就是反应条件的正确与否。

真   1   True。

假   0   False。  

1 s1 = ‘王大锤‘
2 s2 = ‘ ‘  #  字符串中有空格
3 s3 = ‘‘
4 print(bool(s1))  #  结果为True
5 print(bool(s2))  #  结果为True
6 print(bool(s3))  #  结果为false

View Code

bool转换成字符串： bool ---> str

1 print(str(True), type(str(True)))
2 #  执行结果为    True  <class ‘str‘>
3 #   虽然结果还是true， 但是这时已转换成字符串格式

View Code

三. str

1. 字符串的索引与切片

　　索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推

1 a = ‘ABCDEFGHIJK‘
2 print(a[0])  # 结果为 A，因为从0开始，所以0为第一个
3 print(a[3])  # 结果为 D，因为从0开始，所以3为第4个
4 print(a[5])  # 结果为 F，因为从0开始，所以5为第6个
5 print(a[7])  # 结果为 H，因为从0开始，所以7为第8个

View Code

2. 切片就是通过索引（索引：结尾索引+1  ：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）

1 a = ‘ABCDEFGHIJK‘
2 print(a[0:3])  # 结果为ABC
3 print(a[2:5])  # 结果为CDE
4 print(a[0:])  # 0：表示默认到最后，可以取到k元素 结果为ABCDEFGHIJK
5 print(a[0:-1])  # -1 是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到K元素，结果为ABCDEFGHIJ
6 print(a[0:5:2])  # 加步长，从0-5元素，步长为2，结果为:ACE
7 print(a[5:0:-2])  # 反向加步长，从左第5个元素起至末尾，步长为2，结果为:FDB

View Code

3. 常用方法： 对字符串操作形成的都是新的字符串

  1 # captalize, swapcase, title
  2 name = ‘daChui‘
  3 print(name.capitalize()) # 首字母大写,其他小写，已大写的也小写
  4 print(name.swapcase()) # 大小写翻转
  5 msg=‘hello word, zhenhao!‘
  6 print(msg.title()) # 每个单词的首字母大写
  7 
  8 # center  内同居中，设置总长度，空白处填充
  9 a1 = ‘dachui‘
 10 a2 = a1.center(10, "*")  # 设置总长度为10，不足的空白处用*填充
 11 print(a2)  # 结果为**dachui**
 12 
 13 # title()  非字母隔开的‘单词‘首字母大写
 14 ss = ‘hello me2dachui*word‘
 15 s4 = ss.title()
 16 print(s4)  # 结果为 Hello Me2Dachui*Word ， 以非字母*隔开的单词也要首字母大写
 17 
 18 # upper() 全大写   lower() 全小写
 19 s = ‘daChui‘
 20 s5 = s.upper()
 21 print(s5)  # 结果为DACHUI
 22 s6 = s.lower()
 23 print(s6)  # 结果为dachui
 24 
 25 
 26 # count 数字符串中的元素出现的个数。
 27 ret3 = a1.count("a",0,4) # 可切片
 28 print(ret3)
 29 
 30 a2 = "hqw	"
 31 # 	前面的补全
 32 # 默认将一个tab键变成8个空格，如果tab前面的字符长度不足8个，则补全8个，如果tab键前面的字符长度超过8个不足16个则补全16个，以此类推每次补全8个。
 33 ret4 = a2.expandtabs()
 34 print(ret4)
 35 
 36 
 37 # startswith 判断是否以...开头
 38 # endswith 判断是否以...结尾
 39 a4 = "dkfjdkfasf54"
 40 ret4 = a4.endswith(‘jdk‘, 3, 6)  # 顾头不顾腚，到第几个字符，就用索引号-1
 41 print(ret4)  # 返回的是布尔值true
 42 ret5 = a4.startswith(‘jdk‘, 3)  # 以...开始的，可以省略末尾索引
 43 print(ret5)  # 返回的是布尔值 true
 44 ret6 = a4.endswith(‘f54‘, 9)  # 以...结束的，可以省略末尾索引
 45 print(ret6)  # 返回的是布尔值true
 46 ret7 = a4.startswith("kfj", 1, 4)
 47 print(ret7)  # 返回的是布尔值true
 48 
 49 
 50 # find  通过元素找索引，找不到返回-1  ***
 51 # index 通过元素找索引，找不到报错  ***
 52 s = ‘oldboy‘
 53 print(s.find(‘d‘))  # 结果为 2
 54 print(s.find(‘o‘))  # 结果为 0
 55 print(s.find(‘A‘))  # 结果为 -1，因为没找到
 56 print(s.index(‘d‘))  # 结果为 2
 57 print(s.index(‘A‘))  # 结果报错
 58 print(s.find("db", 1, 4))  # 结果为2,只返回d的索引
 59 
 60 
 61 # split 以什么分割，最终形成一个列表此列表不含有这个分割的元素。可将str 转换为 list
 62 ret9 = ‘title, Tilte, atre,‘.split(‘t‘)
 63 print(ret9)  # 结果为: [‘‘, ‘i‘, ‘le, Til‘, ‘e, a‘, ‘re,‘]
 64 ret91 = ‘title, Tilte, atre,‘.rsplit(‘t‘, 1)
 65 print(ret91)  # 结果为: [‘title, Tilte, a‘, ‘re,‘] ，参数为1， 只分割右边第一个
 66 s = ‘我 是 谁‘
 67 print(s.split())  # 默认按照空格分割,结果为: [‘我‘, ‘是‘, ‘谁‘]
 68 
 69 
 70 # format的三种玩法 格式化输出
 71 res = ‘{} {} {}‘.format(‘egon‘, 18, ‘male‘)
 72 print(res)  # 结果为： egon 18 male
 73 res1 = ‘{1} {0} {1}‘.format(‘egon‘, 18, ‘male‘)
 74 print(res1)  # 结果为： 18 egon 18
 75 res2 = ‘{name} {age} {sex}‘.format(sex=‘male‘, name=‘egon‘, age=18)
 76 print(res2)  # 结果为： egon 18 male
 77 
 78 # strip 默认去除str前后两端换行符，制表符  空格  ***  中文
 79 name = ‘*egon**‘
 80 print(name.strip(‘*‘))  # 去除所有的*
 81 print(name.lstrip(‘*‘))  # 只去除左边的*
 82 print(name.rstrip(‘*‘))  # 只去除右边的*
 83 
 84 # replace  把字符串中的 旧字符串 替换成 新字符串
 85 ame = ‘我 是 大鱼 我 是 大鱼‘
 86 print(name.replace(‘大鱼‘, ‘小美‘))  # 结果为: 我 是 小美 我 是 小美
 87 print(name.replace(‘大鱼‘, ‘小美‘, 1))  # 结果为： 我 是 小美 我 是 大鱼，加了参数1后，只替换了第一个元素
 88 
 89 
 90 # join   将原有的 列表 或 字符串 中的 元素 以指定的 字符 连接生成一个新的 字符串，用途将 list 转换为 str
 91 s = ‘-*—‘
 92 s1 = ‘bcd‘
 93 s2 = [‘b‘, ‘c‘, ‘d‘]
 94 print(‘_‘.join(s1))  # 结果为 b_c_d
 95 print(s.join(s1))  # 结果为 b-*—c-*—d
 96 print(s.join(s2))  # 结果为 b-*—c-*—d ,列表（list）也可以用此方法
 97 print(s1.join(s))  # 结果为-bcd*bcd—,因为s中的元素被s1连接的时候，
 98 print(‘x‘.join(s1))  # 结果为 bxcxd
 99 l1 = [‘wo‘, ‘shi‘, ‘shui‘] # 转换为字符换 ‘wo shi shui‘
100 print(‘ ‘.join(l1))  # 结果为: wo shi shui
101 
102 
103 # is系列
104 name=‘dachui456‘
105 print(name.isalnum())  # 字符串由字母或数字组成
106 print(name.isalpha())  # 字符串只由字母组成
107 print(name.isdigit())  # 字符串只由数字组成  str ---> int 可以作为一个判断条件
108 
109 # 公共方法 len count
110 # len 测量个数，返回对象（字符、列表、元组等）长度或项目个数
111 s = ‘qwer123 qwq‘
112 ss = ‘‘
113 print(len(s))  # 结果为11，空格也会统计
114 print(len(ss))  # 结果为0，统计不到不会报错，会返回0
115 # count 某个元素出现的次数,可选参数为在字符串搜索的开始与结束位置
116 print(s.count(‘q‘))  # 结果为3
117 print(s.count(‘4‘))  # 结果为0，统计不到不会报错，会返回0

View Code

 四. tuple

元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。例：（1，2，3）（"a","b","c"）

 tu = (1, True, [12, 3], ‘afdlsfa‘)
可以索引，可以切片（步长）。
不能增删改（儿子不能，孙子有可能），只能查询。
index  count  for 循环。

1 tu = (1, True, [12, 3], ‘afdlsfa‘)
2 tu[2][0] = 5  # tu中的第2个索引中的第0个索引的值，即12 修改为 5
3 print(tu)  # 结果为:(1, True, [5, 3], ‘afdlsfa‘)， 值已被修改，即孙子可以被改

View Code

五. list

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

1. 索引切片。(与字符串一样)