老男孩笔记-2.Python数据类型及其内置方法

一. 数字类型(int, float

一个值; 不可变;

1. WHAT

见名知意, 不解释

# 数据类型转换
int()  # 强制转换成整型
float()  # 强制转换成浮点型

2. WHICH

• int: 整数
• float: 小数(浮点数)
• complex: 复数
• long: 长整形(python3中已废弃)

3. HOW

用于数学运算或比较运算

二. str字符串类型

一个值; 不可变;

1. WHAT

字符串: 一个或多个字符在一起的类型

# 数据类型转换
str()  # 强制转换成字符串

2. WHICH

哪里都要使用, 不解释

3. HOW

以下操作需掌握

3.1 字符串切片(顾头不顾尾)

msg[头:尾:步长]  # 步长为负数为反向切片
msg[:]  # 字符串复制
msg[::-1]  # 字符串取反

3.2 返回字符串长度

len(msg)  # 空格也计算在字符长度内

3.3 移除空白字符串

msg.strip()  # 默认移除首尾连续的空白字符(含空格,\t,\n)
msg.lstrip()  # 移除开头连续的空白字符(了解就好)
msg.rstrip()  # 移除结尾连续的空白字符(了解就好)
msg.strip('*')  # 移除括号内的指定字符; lstrip(), rstrip()同理

3.4 字符串按指定字符分割

msg.strip()  # 默认以空白字符(含空格,\t,\n)为分割
msg.strip('.') # 按括号内的指定字符分割

3.5 字符串按索引取值

msg[0]  # 从左往右取字符串的第一个字符
msg[-1]  # 从右往左取字符串的第一个字符
# 字符串内的值不能变更
str1[0]='H' # 报错TypeError

3.6 判断子字符串 in和not in

sub_msg in msg  # 判断sub_msg是否在msg中
sub_msg not in msg # 判断sub_msg不在msg中

3.7 字符串大小写转换

msg.lower()  # 将msg字符串全部变小写并返回
msg.upper()  # 将msg字符串全部变大写并返回
# 以下函数了解即可
msg.capitalize() # 将msg字符串首字母大写并返回
msg.swapcase() # 将msg字符串大小写翻转并返回
msg.title() # 将msg字符串每个单词首字母大写并返回

3.8 判断开始字符串或结束字符串

msg.startswith('t')  # 判断msg字符串是否以t开头
msg.endswith('t')  # 判断msg字符串是否以t结尾

3.9 format格式化输出

msg = = 'my name is {name}, my age is {age}!'.format(age=18,name='tony')

3.10 字符串连接

>>> '*'.join('str1')  # 从str1字符串中取出每个字符, 用*作为分隔符进行连接
's*t*r*1'
>>> '|'.join(['tony','18','read'])  # 从列表中取出多个字符串，然后按照*作为分隔符号进行拼接
'tony|18|read'

3.11 字符串替换

msg.replace('old_str','new_str')  # 将msg字符串中的所有old_str字符串替换成new_str字符串,并返回, 默认查找所有字符串, 不限次数
msg.replace('old_str','new_str',1)  # 将msg字符串中的第一个old_str字符串替换成new_str字符串,并返回; 负数无效, 为全部替换

3.12 判断字符串是否是阿拉伯数字

msg.isdigit()  # 判断msg字符串是否是纯阿拉伯数字组成

3.13 字符串查找

# find: 从指定范围内查找子字符串的起始索引，找得到则返回索引，找不到则返回-1
msg.find('a',1,3) # 在索引为1和2(顾头不顾尾)的字符中查找字符a的索引
# index: 从指定范围内查找子字符串的起始索引，找得到则返回索引，找不到则报错ValueError
msg.index('a',1,3) # 在索引为1和2(顾头不顾尾)的字符中查找字符a的索引
# rfind, rindex: 从指定范围内从右往左查找子字符串的起始索引, 其他同find及index

以下操作需了解

3.14 字符串统计

msg.count('e')  # 统计字符串e在字符串msg中出现的次数
msg.count('e',1,6)  # 统计字符串e在字符串msg索引1~5范围内出现的次数

3.15 字符串填充

# 左填充
msg.ljust(30,'+') # 总宽度为30, msg字符串左对齐显示, 不够用+填充
# 右填充
msg.rjust(30,'+') # 总宽度为30, msg字符串右对齐显示, 不够用+填充
# 居中填充
msg.center(30,'+') # 总宽度为30, msg字符串居中对齐显示, 不够用+填充
# 填充0
msg.zfill(30) # 总宽度为30, 字符串右对齐显示, 不够用0填充

3.16 字符串制表符空格数变更

msg.expandtabs(3) # 将msg字符串中\t空格数修改为3个

3.17 判断字符串是否是数字(含中文或罗马数字)

msg.isnumeric() # 判断字符串是否是数字(含中文或罗马数字)
# 总结:
#     最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
#     如果要判断中文数字或罗马数字,则需要用到isnumeric。

3.18 判断字符串其他系列

# 判断字符串是否是纯数字或纯字母或数字和字母组合
msg.isalnum()
# 判断字符串是否是纯字母
msg.isalpha()
# 判断字符串是否全是空白字符(含空格, \n, \t)
msg.isspace()
# 判断字符串是否是关键字
msg.isidentifier()
# 判断字符串是否纯大写
msg.isupper()
# 判断字符串是否纯小写
msg.islower()
# 判断字符串的单词首字母是否都是大写
msg.istitle()

三. list列表类型

多个值; 有序; 可变

1. WHAT

定义：在[]内,用逗号分隔开多个任意数据类型的值

list()  # 强制转换成列表
# 凡能被for循环遍历的数据类型都被list()转换成列表类型，list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中
list('abc') # 结果：['a', 'b', 'c'] 
list([1,2,3]) # 结果：[1, 2, 3]
list({"name":"egon","age":18}) # 结果：['name', 'age']
list((1,2,3)) # 结果：[1, 2, 3] 
list({1,2,3,4}) # 结果：[1, 2, 3, 4]

2. WHICH

用于表达同一种属性的多个值的时候使用

3. HOW

以下操作需掌握

3.1 列表按索引取值

lst[0]  # 从左往右取列表的第一个值
lst[-1]  # 从右往左取列表的第一个值
# 按照索引修改指定位置的值，如果索引不存在则报错
lst[1] = 'tom'

3.2 列表切片(顾头不顾尾)

lst[头:尾:步长]  # 步长为负数为反向切片
lst[:]  # 列表复制
lst[::-1]  # 列表取反

3.3 返回列表长度

len(lst)

3.4 成员运算in和not in

'msg' in lst
'msg' not in lst

3.5 添加

lst = [1,2]
# append()列表尾部追加一个元素
lst.append([1,2]) # 结果: [1,2,[1,2]]
# extend()列表尾部追加多个元素(按for循环一样遍历出数据类型中包含的每一个元素追加列表中)
lst.extend({'name':'egon','age':18}) # 结果: [1,2,'name','age']
# insert()在指定位置插入元素
lst.insert(0,"first")  # 0表示按索引位置插值

3.6 删除

lst = ['a','b','c']
# del
del lst[0]  # 删除索引为0的元素, 没有返回值
# pop() 
lst.pop() # 默认删除列表最后一个元素，并将删除的值返回; 结果['a','b'], 返回值'c'
lst.pop(0) # 括号内可以指定索引值来删除特定元素; 结果['b','c'], 返回值'a'
# remove()
lst.remove('a') # 从左往右查找第一个括号内需要删除的元素, 无返回值; 查找不到,报错ValueError

3.7 排序

# sort()给列表内所有元素排序, 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
lst.sort()
lst.sort(reverse=True)  # reverse用来指定是否跌倒排序，默认为False

3.8 倒序

# reverse()颠倒列表内元素顺序
lst.reverse()
# 方法二: 切片
lst[::-1]

3.9 拷贝

src_l = [11, 22, [33, 44]]
# 浅copy
dst_l=src_l[:]  # 浅copy
dst_l=src_l.copy()  # 浅copy
# 深copy
from copy import deepcopy
dst_l = deepcopy(src_l)  # 深copy

四. tuple元组类型

多个值; 有序; 不可变

1. WHAT

定义: 在()内用逗号分隔开多个任意类型的值
如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组

tuple()  # 强制转换成元组
# 但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
>>> tuple('abc') # 结果：('a', 'b', 'c') 
>>> tuple([1,2,3]) # 结果：(1, 2, 3)
>>> tuple({"name":"jason","age":18}) # 结果：('name', 'age')
>>> tuple((1,2,3)) # 结果：(1, 2, 3)
>>> tuple({1,2,3,4}) # 结果：(1, 2, 3, 4)
# tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中

2. WHICH

3. HOW

3.1 元组按索引取值, 只能取，不能改否则报错：TypeError

tup[0]  # 从左往右取元组的第一个值
tup[-1]  # 从右往左取元组的第一个值

3.2 元组切片(顾头不顾尾)

tup[头:尾:步长]  # 步长为负数为反向切片
tup[:]  # 元组复制
tup[::-1]  # 元组取反

3.3 返回元组长度

len(tup)

3.4 成员运算in和not in

'msg' in tup
'msg' not in tup

3.5 添加, 删除,排序

元组不可变, 所以不能直接添加,删除,排序

五. dict字典类型

多个值; 无序; 可变

1. WHAT

定义：在{}内用逗号分隔开多元素，每一个元素都是key:value的形式，其中value可以是任意类型，而key则必须是不可变类型，通常key应该是str类型，因为str类型会对value有描述性的功能

info={'name':'tony','age':18,'sex':'male'} #本质info=dict({....})
dict()  # 强制转换成字典

2. WHICH

3. HOW

以下操作需掌握

3.1 取值

dic = {
        'name': 'xxx',
        'age': 18,
        'hobbies': ['play game', 'basketball']
}
# 方法一: 直接取值
dic['name']  # key存在，则获取key对应的value值; key不存在，报错
# 方法二: get()取值
dic.get('name')  # key存在，则获取key对应的value值; key不存在，返回None
# 获取字典所有的key
dic.keys() 
# for循环取字典所有的key
for key in dic:
    print(key)
# 获取字典所有的value
dic.values()
# 获取字典所有的键值对
dic.items()

3.2 新增或更新赋值

# 更新赋值
dic['name'] = 'tony'  # 如果key原先存在于字典，则会修改对应value的值
dic.update({'name':'JK','age':20})  # 如果key原先存在于字典，则会修改对应value的值
# 新增
dic['gender'] = 'male'  # 如果key原先不存在于字典，则会新增key:value
dic.update({'name':'JK','age':20})  # 如果key原先不存在于字典，则会新增key:value
# 快速新增字典并附上默认值
dic = dict.fromkeys(['k1','k2','k3'],[])
# setdefault()
dic.setdefault('k3',333)  # key不存在则新增键值对，并将新增的value返回; key存在则不做任何修改，并返回已存在key对应的value值

3.3 删除

dic.pop('name')  # 通过指定字典的key来删除字典的键值对
dic.popitem()  # 随机删除一组键值对,并将删除的键值放到元组内返回

3.4 返回列表长度

len(dic)

3.5 成员运算in和not in

'msg' in dic  # 判断某个值是否是字典的key
'msg' not in dic  

六. set集合类型

多个值; 无序; 可变

1. WHAT

定义: 在{}内用逗号分隔开多个元素
特点:
1：每个元素必须是不可变类型
2：集合内没有重复的元素
3：集合内元素无序

d = {} # 默认是空字典 
s = set() # 定义空集合
set()  # 强制转换成集合
# 凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型

2. WHICH

主要用于：去重、关系运算

3. HOW

3.1 关系运算

friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们 
friends2 = {"Jy","ricky","jason","egon"}   # 用户2的好友们
# 1.合集/并集(|)：求两个用户所有的好友（重复好友只留一个）
>>> friends1 | friends2
{'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}

# 2.交集(&)：求两个用户的共同好友
>>> friends1 & friends2
{'jason', 'egon'}

# 3.差集(-)：
>>> friends1 - friends2 # 求用户1独有的好友
{'kevin', 'zero'}
>>> friends2 - friends1 # 求用户2独有的好友
{'ricky', 'Jy'}

# 4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）
>>> friends1 ^ friends2
{'kevin', 'zero', 'ricky', 'Jy'}

# 5.值是否相等(==)
>>> friends1 == friends2
False

# 6.父集：一个集合是否包含另外一个集合
# 6.1 包含则返回True
>>> {1,2,3} > {1,2}
True
>>> {1,2,3} >= {1,2}
True
# 6.2 不存在包含关系，则返回False
>>> {1,2,3} > {1,3,4,5}
False
>>> {1,2,3} >= {1,3,4,5}
False

# 7.子集
>>> {1,2} < {1,2,3}
True
>>> {1,2} <= {1,2,3}
True

3.2 去重

# 局限性:
# 1. 只能针对不可变类型
# 2. 集合本身是无序的，去重之后无法保留原来的顺序

3.3 返回集合长度

len(s)

3.4 成员运算in和not in

'msg' in s
'msg' not in s