Python学习第四篇：Python基本数据类型-详解

一、str 字符串   不可变类型（需要新开内存空间）

字符串比较大小比的是首字母：

print('aabdvc' > 'b')
结果：
False

重点：需要记得功能如下图

 

1、capitalize 字符串首字母大写

　 自身不变，会生成一个新的值

name = 'jianghao'
new_name = name.capitalize()
print(name)
print(new_name)

 结果：

jianghao
Jianghao

 

2、casefold 将所有大写变小写，casefold可以使任何语言的大写变小写

name = 'JiangHAo'
new_name = name.casefold()
print(name)
print(new_name)

 

 

结果：

JiangHAo
jianghao

 

3、lower 将所有大写变小写，lower只可以改变英文

name = 'JIangHao'
new_name = name.lower()
print(name)
print(new_name)

upper 小写变大写  

结果：

JIangHao
jianghao

 

 

4、center  文本居中

# 参数1: 表示总长度
# 参数2：空白处填充的字符（长度为1）

name = 'jianghao'
new_name = name.center(20,'#')
print(name)
print(new_name)

 

结果：

jianghao
######jianghao######

 

5、count 统计传入值在字符串中出现的次数

# 参数1： 要查找的值（子序列）
# 参数2： 起始位置（索引）
# 参数3： 结束位置（索引）

neme = 'jiangohao'
v1 = neme.count('o')
v2 = neme.count('o',0,6)
v3 = neme.count('o',3,9)
print(neme)
print(v1)
print(v2)
print(v3)

 

结果：

jianghao
2
1
2

 

6、endswith 是否以xx结尾，返回值是True或False

name = 'jianghao'
new_name = name.endswith('ao')
print(name)
print(new_name)

 

结果：

jianghao
True

 

7、startswith 是否以xx开头，返回值是True或False

name = 'jianghao'
new_name = name.startswith('ji')
print(name)
print(new_name)

 

结果：

jianghao
True

 

8、expandtabs 找到制表符\t,进行替换（替换范围包含前面的字符,自定义表格）

# 参数默认是8

name = 'ji\tan\tg\nhao\tj\th'
new_name = name.expandtabs(10)
print(name)
print(new_name)

 

结果：

ji    an    g
hao    j    h
ji        an        g
hao       j         h

 

9、 找到指定子序列的索引位置

　　find：存在返回索引位置，不存在返回  -1

　　index：存在返回索引位置，不存在 报错

name = 'jianghao'
v1 = name.find('a')
v2 = name.index('a')
v3 = name.find('a')
# v4 = name.index('x')
print(v1,v2,v3)

 

结果：

2 2 2

 

10、字符串格式化（格式化输出）

      三种方法：

　　% ：根据百分号

v1 = '姓名:%s;年龄:%s;性别:%s'
new_v1 = v1%('姜昊',24,'男')
print(new_v1)

结果：

姓名:姜昊;年龄:24;性别:男

 

%后面可以是变量：
v1 = '姓名:%s'
aa = '姜昊1111'

new_v1 = v1%aa
print(new_v1)

new_v2 = v1%'姜昊2222'
print(new_v2)

　　

        format ：根据下标

v2 = '姓名:{0};年龄:{1};性别:{2}'
new_v2 = v2.format('姜昊',24,'男')
print(new_v2)

 

结果：

姓名:姜昊;年龄:24;性别:男

 

　　format ：根据名字对应

1 v4 = '姓名:name;年龄:age;性别:sex'
2 new_v4 = v4.format(name=姜昊,age=24,sex=男)
3 print(new_v4)

 

结果：

姓名:姜昊;年龄:24;性别:男

 

　　format_map ：根据键值对

v3 = '姓名:{name};年龄:{age};性别:{gender}'
new_v3 = v3.format_map({'name':'姜昊','age':24,'gender':'男'})
print(new_v3)

 

结果：

姓名:姜昊;年龄:24;性别:男

 

11、isalnum 判断是否是数字、字母、汉字

# 数字、字母、汉字  True

# 特殊符号 False

name1 = 'jianghao123姜昊'
name2 = 'jianghao123姜昊@'
v1 = name1.isalnum()
v2 = name2.isalnum()
print(v1,v2)

isalpha 判断是否是字母、汉字

结果：

True False

 

12、判断是否是数字

isdecimal  # '123'

isdigit   # '123'，'②'

isnumeric   # '123'，'二'，'②'

num1 = "123"
num2 = "②"
num3 = "二"
v1 = num1.isdecimal()    # '123'
v2 = num2.isdigit()      # '123'，'②'
v3 = num3.isnumeric()    # '123'，'二'，'②'
print(v1,v2,v3)

 

结果：

True True True

13、isidentifier 判断变量名是否合法

name1 = 'jianghao1'
name2 = '1jianghao'
v1 = name1.isidentifier()
v2 = name2.isidentifier()
print(v1,v2)

 

结果：

True False

 

14、islower 判断是否全部是小写

name1 = 'jianghao'
name2 = 'JIanghao'
v1 = name1.islower()    #判断是否全部是小写
v2 = name2.islower()    #判断是否全部是小写
print(v1,v2)

 

结果：

True False

 

　　isupper 判断是否全部是大写

name3 = 'JIANGHAO'
name4 = 'JIANGhao'
name5 = 'JIANG12'
v3 = name3.isupper()    #判断是否全部是大写
v4 = name4.isupper()    #判断是否全部是大写
v5 = name5.isupper()    #判断是否全部是大写
print(v3,v4,v5)

 

结果：

True False True

 

15、upper 全部变大写

name = 'jianghao'
new_name = name.upper()
print(name)
print(new_name)

 

结果：

JIANGHAO

 

　　 lower 全部变小写

name = 'JIANGHAO'
new_name = name.lower()
print(name)
print(new_name)

 

结果：

jianghao

 

16、isprintable 是否包含隐含的\n \t

#不包含返回True ，包含返回False

name1 = 'guoshaolong'
name2 = 'guo\nshao\nlong'
v1 = name1.isprintable()
v2 = name2.isprintable()
print(v1,v2)

 

结果：

True False

 

17、isspace 是否全部是空格

name = '  '
v = name.isspace()
print(v)

 

结果：

True

 

18、元素拼接（元素的是字符串或字符,不能是数字） 重要程度五颗星***** --- 以每个元素来循环，所以字符串、列表、字典都行

name = 'jianghao'
v1 = "_".join(name)
print(v1)

name_list = ['张三','李四','王五']
v2 = "*".join(name_list)
print(v2)

结果：

j_i_a_n_g_h_a_o
张三*李四*王五

 

19、左右填充

　　center　　文本居中（详见第4个）

　　rjust　　右填充

　　ljust　　左填充

name = 'jianghao'
v1 = name.rjust(20 ,"*")    #右填充
v2 = name.ljust(20 ,"*")    #左填充
print(v1)
print(v2)

 

结果：

************jianghao
jianghao************

 

20、对应关系 + 翻译（对应的字符做替换）

m = str.maketrans('aeio','1234')#将aeio各自对应转换成1234
name = 'abcdefghijklmnopqrstuvwxyz'
v = name.translate(m)
print(v)

 

结果：

1bcd2fgh3jklmn4pqrstuvwxyz

 

21、partition 分割，保留分割的元素   split分割不保留

name1 = 'jianghao'
name2 = 'jia.nghao'
name3 = 'jianghao'
v1 = name1.partition('.') #以.分割并且包含.
v2 = name2.partition('.')
v3 = name3.partition('a')
print(v1)
print(v2)
print(v3)

 

结果：

('jianghao', '', '')
('jia', '.', 'nghao')
('ji', 'a', 'nghao')

22、replace 替换

name = 'jia.ngha.o'
v1 = name.replace('.','*')
v2 = name.replace('.','*',1) #只替换第一个.
print(v1)
print(v2)

 

结果：

jia*ngha*o
jia*ngha.o

 

23、strip 移除空白,\n,\t

name1 = '  jianghao'  #\t \n也相当于空白
name2 = 'jianghao\t'
name3 = '  jianghao\t'
name4 = '  jianghao\n'
v1 = name1.strip()
v2 = name2.strip()
v3 = name3.strip()
v4 = name3.strip()
print(name1)
print(v1)
print(v2)
print(v3)
print(v4

 

结果：

  jianghao
jianghao
jianghao
jianghao
jianghao

 

24、swapcase 大小写转换

name = 'JiangHao'
v = name.swapcase()
print(name)
print(v)

 

结果：

jIANGhAO

 

25、zfill 往前面填充0（数字指整体）

name = 'jianghao'
v = name.zfill(20)
print(v)

 

结果：

000000000000jianghao

 

26、encode 转换成字节（只有字符串有endoce），把中文的字符串转换成010101...  ，为了方便显示最后看到的表现形式自动转成16进制显示

name = '姜昊'
v1 = name.encode(encoding='utf-8')
v2 = name.encode(encoding='gbk')
print(v1)
print(v2)

 

结果：

b'\xe5\xa7\x9c\xe6\x98\x8a'   #前面有个b---字节类型，\x--表示16进制
b'\xbd\xaa\xea\xbb'

 

 

额外功能--- 切片，循环等

二、int 整数

1、bit_length 当前整数的二进制表示，最少位数

 1 age1 = 1
 2 age2 = 10
 3 age3 = 100
 4 print(age1.bit_length())
 5 print(age2.bit_length())
 6 print(age3.bit_length())
 7 
 8 输出内容：
 9 1
10 4
11 7

2、to_bytes  获取当前数字的字节表示。前面的10表示用几个字节来表示这个，不足的用0补满。big表示在后补齐在前，little表示放在前

1 age = 20
2 v1 = age.to_bytes(10,byteorder='big')
3 v2 = age.to_bytes(10,byteorder='little')
4 print(v1)
5 print(v2)
6 
7 输出内容：
8 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14'
9 b'\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00'

三、bool 布尔值

1、只有True或False

 1 v1 = 0
 2 v2 = 1
 3 v3 = -1
 4 v4 = ''
 5 v5 = []
 6 print(bool(v1))
 7 print(bool(v2))
 8 print(bool(v3))
 9 print(bool(v4))
10 print(bool(v5))
11 
12 输出内容：
13 False
14 True
15 True
16 False
17 False

0是False，其他如负数正数都是True

""是Flase，" "是True

[]是Flase，有值是True

----> 空内容是：Flase

     

   字典、列表，通过引用赋值，一个修改都变

四、list 列表  可变类型           内存指定同一地址

列表生成式：
q = [e for e in range(10)]
print(q)

结果：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

 

1、append 追加 --- list是可变类型，内容可更新，列表追加是加到原来的列表里去了，新生成的只能得到空；字符串是不可变类型，原那里的不可改，只能生成新的。

1 user_list = ['老大','老二','老三','老四']
2 user_list.append('老五')
3 print(user_list)
4 
5 输出内容：
6 ['老大', '老二', '老三', '老四', '老五']

以后可以执行功能后去看是否返回值，没返回就是自身发生变化

 

2、clear 清空

1 user_list = ['老大','老二','老三','老四']
2 user_list.clear()
3 print(user_list)
4 
5 输出内容：
6 []

3、copy 拷贝(浅拷贝)，拷贝生成新的，进行浅拷贝后A与B指向同一地址，修改A就修改B；深拷贝就是将A复制给B的同时，给B创建新的地址

1 user_list = ['老大','老二','老三','老四']
2 v = user_list.copy()
3 print(user_list)
4 print(v)
5 
6 输出内容：
7 ['老大', '老二', '老三', '老四']
8 ['老大', '老二', '老三', '老四']

4、count 计数

1 user_list = ['老大','老二','老三','老四','老三']
2 v = user_list.count('老三')
3 print(user_list)
4 print(v)
5 
6 输出内容：
7 ['老大', '老二', '老三', '老四', '老三']
8 2

5、extend 扩展原列表

1 user_list = ['老大','老二','老三','老四']
2 user_list.extend(['郭少龙','少龙'])
3 print(user_list)
4 
5 输出内容：
6 ['老大', '老二', '老三', '老四', '郭少龙', '少龙']

6、index 查找元素索引，不存在则报错  （user_list[~1]  反向取值从反向0开始算，user_list[-1]从反向1开始算  ）

1 user_list = ['老大','老二','老三','老四']
2 v = user_list.index('老大')

2 v = user_list.index('老大'，0，2)  #从0位值开始到2结束

3 print(v)
4 
5 输出内容：
6 0
7 0

7、pop 删除并且获取元素 - 根据索引删除

1 user_list = ['老大','老二','老三','老四']
2 v = user_list.pop(1)
3 print(v) #得到删除值
4 print(user_list)
5 
6 输出内容：
7 老二
8 ['老大', '老三', '老四']

8、remove 删除 - 根据值删除

1 user_list = ['老大','老二','老三','老四']
2 user_list.remove('老二')
3 print(user_list)
4 
5 输出内容：
6 ['老大', '老三', '老四']

9、reverse 翻转倒序

1 user_list = ['老大','老二','老三','老四']
2 user_list.reverse()
3 print(user_list)
4 
5 输出内容：
6 ['老四', '老三', '老二', '老大']

10、sort  排序 ，默认是正序 从小到大  （可以传参数指定根据谁来排序）

 1 正序：
 2 nums = [5,4,3,2,6,10,7]
 3 nums.sort()
 4 print(nums)
 5 
 6 输出内容：
 7 [2, 3, 4, 5, 6, 7, 10]
 8 
 9 
10 倒序：
11 nums = [5,4,3,2,6,10,7]
12 nums.sort(reverse=True)
13 print(nums)
14 
15 输出内容：
16 [10, 7, 6, 5, 4, 3, 2]

额外：

索引取值，切片 A[0]   A[1:5:2]

for循环，每一个就是里面的元素

修改，直接赋值：A[1] = new

 

11、补充内容：range  

三个参数，     第二个参数不输出（输出到第二个之前的）

2.7：立即生成所以数字，直接使用， 有个xrange跟3相同

3：不立即生成，优化后需要创建range(1,11)后再次使用，只有循环迭代时，才一个一个生成

　　1、输出1-10

 1 for i in range(1,11):
 2     print(i)
 3 
 4 输出内容：
 5 1
 6 2
 7 3
 8 4
 9 5
10 6
11 7
12 8
13 9
14 10

　　2、输出1-10 奇数，第三个参数是步长，步长可为负数便是倒数生成

1 for i in range(1,11,2):
2     print(i)
3 
4 输出内容：
5 1
6 3
7 5
8 7
9 9

　　3、倒序输出10-1

 1 for i in range(10,0,-1):
 2     print(i)
 3 
 4 输出内容：
 5 10
 6 9
 7 8
 8 7
 9 6
10 5
11 4
12 3
13 2
14 1

　　4、输出列表内容+序号

1 name = ['张三','李四','王五']
2 for i in range(0,len(name)):
3     print(i+1,name[i])
4 
5 输出内容：
6 1 张三
7 2 李四
8 3 王五

 

12、补充内容：enumerate  ，新生成一列有序的数字，可做为索引，参数2是只从哪个数字开始

1 name = ['张三','李四','王五']
2 for i,ele in enumerate(name,1):
3     print(i,ele)
4 
5 输出内容：
6 1 张三
7 2 李四
8 3 王五

for i,e in enumerate(li,1):
    print(i,e)
v = input("sss :")
print(li[int(v)-1])

　　

五、tuple：元组（不可被修改的列表；不可变类型） 元组元素不可以被修改，元素整体不可以被修改，但是元素里面的元素可以被修改

# 元组如果只有一个值，需要在最后加逗号

元组最后加个逗号“，”  （虽然不加也是元组，但是会被其他的误解-python语法塘问题）

li  =('alex',)

 

1、count 获取个数

1 user_tuple = ('张三','李四','王五','张三',)
2 v = user_tuple.count('张三')
3 print(v)
4 
5 输出内容：
6 2

2、index 获取值的第一个索引位置

1 user_tuple = ('张三','李四','王五','张三',)
2 v = user_tuple.index('张三')
3 print(v)
4 
5 输出内容：
6 0

for循环

索引取值

 

六、dict：字典      可变类型，修改自身

1、clear 清空

1 dic = {'k1':'v1','k2':'v2'}
2 dic.clear()
3 print(dic)
4 
5 输出内容：
6 {}

2、copy 浅拷贝

1 dic = {'k1':'v1','k2':'v2'}
2 v = dic.copy()
3 print(dic)
4 print(v)
5 
6 输出内容：
7 {'k2': 'v2', 'k1': 'v1'}
8 {'k2': 'v2', 'k1': 'v1'}

3、get 根据key获取指定的value；不存在不报错

1 dic = {'k1':'vvv','k2':'vv'}
  v2 = dic.get('k1')
2 v1 = dic.get('k111','111') #存在则输出参数一对应的值，不存在则输出参数二
3 print(v1)
4 print(v2)
5 输出内容：
6 111
  vvv
v = dic['k111']    #这种方法取值的时候若是key不存在会报错，用get不会报错
print(v)

4、pop 删除并且可以获取对应的value值

1 dic = {'k1':'v1','k2':'v2'}
2 v1 = dic.pop('k1')
3 print(v1)
4 
5 输出内容：
6 v1

5、popitem 随机删除键值对，并获取到删除的键值  ，因为字典是无序的

1 dic = {'k1':'v1','k2':'v2'}
2 v = dic.popitem()
  k,v = dic.popitem() #这样就key给k，value给v 
3 print(v)
4 print(dic)
  print(k,v)          #等于 print(v[0],v[1])
5 
6 输出内容：
7 ('k2', 'v2')
8 {'k1': 'v1'}

6、setdefault 增加键值对，如果key存在则不做操作

1 dic = {'k1':'v1','k2':'v2'}
2 dic.setdefault('k3','v3')
3 print(dic)
4 
5 输出内容：
6 {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

7、update 批量增加或修改键值对，如果key存在就更新

dic = {'k1':'v1','k2':'v2'}

v1 = {'k1':'111'}

dic.update({'k3':'v3','k1':'v33333'})
dic.updata(v1) 
print(dic) 

输出内容： 
{'k2': 'v2', 'k1': 'v33333', 'k3': 'v3'}

额外1：

- 字典可以嵌套

- 字典的key必须是不可变类型（如元组可以--但是要是元组的元素是可变类型也不可以，如(1,2,[3,4])不行）

- 字典的key会被转换成hash值存在内存里，可变类型不可被hash-会递归的找不稳定因素，不可变能被hash

- 字典里面True就等于1，0就是False (111这种是在bool()转换时候成了True)

- 字典删除del dic['k1']

额外2：

fromkeys 循环列表生成字典

dic = dict.fromkeys(['k1','k2','k3'],123)
print(dic)

结果：
{'k2':123,'k1':123,'k3':123}

 

dic = dict.fromkeys(['k1','k2','k3'],[1，])
dic['k1'].append(222)
print(dic)

结果：
{'k2':[1,222],'k1':[1,222],'k3':[1,222]}

因为[1,]是可变类型 append添加的是对应的内存地址，修改一个等于修改同样的内存地址结果所有的都修改了

 

额外3：

 

　　

七、集合，set    可变类型 == 不可重复的列表,特殊的列表，长得像字典但没有键值对，里面的元素需要是不可变的

可以:

add

clear

copy

不支持索引

 

1、s1中存在，s2中不存在  ---  difference

 1 s1 = {"a",'b','c','d','e'}
 2 s2 = {"a",'b','c','d','f'}
 3 v = s1.difference(s2)
 4 print(v)

 5 输出内容:
   {'e'}

2、s1中存在，s2中不存在和s2中存在，s1中不存在 --- 并集  symmetric_difference

 6 v = s1.symmetric_difference(s2)
 7 print(v)
 8 
 9 输出内容：
10 {'e','f'}

 

3、s1中存在，和s2中存在的   --- 交集  intersection

6 v = s1.intersection(s2)
 7 print(v)
 8 
 9 输出内容：
10 {"a",'b','c','d'，'e','f'}

 

4、 s1中存在，s2中不存在，然后对s1清空，然后重新赋值s1  --- difference_updat   带update就是给原来的重新赋值

 6 s1.difference_update(s2)
 7 print(s1)
 8 
 9 输出内容：
10 {'e'}

 

更新 -- update　

存在的更新，不存在的加在后面

　

5、移除 --- discard

s1 = {"a",'b','d','e'}
s1.discard('b')
print(s1)
 
输出内容：
{'a','d','e'}