Python基本数据类型

1. 整型（int）

1.1 其它类型转换为整型

可以通过 type() 来查看变量到底是什么类型

# 布尔值转整型
n1 = int(True)  # True转换为整数 1
n2 = int(False) # False转换为整数 0

# 字符串转整型
v1 = int("186", base=10)   # 把字符串看成十进制的值，然后再转换为 十进制整数，结果：v1 = 186
v2 = int("0b1001", base=2) # 把字符串看成二进制的值，然后再转换为 十进制整数，结果：v1 = 9 (0b表示二进制)
v3 = int("0o144", base=8)  # 把字符串看成八进制的值，然后转换为 十进制整数，结果：v1 = 100 (0o表示八进制)
v4 = int("0x59", base=16)  # 把字符串看成十六进制的值，然后转换为 十进制整数，结果：v1 = 89 （0x表示十六进制）

1.2 Py2和Py3的差异

Python2中有int、long（长整型），长整型都以L结尾 

• int，可表示的范围：-9223372036854775808～9223372036854775807
• long，整数值超出int范围之后自动会转换为long类型（无限制）

Python3中只剩下：int（整型），并且 int 长度不在限制

python2中两个值相除时，默认进行地板除，只保留整数位（python3中默认会保留小数）

2. 布尔值（bool）

布尔值详细内容

布尔值True和False的判断

• 整数0、空字符串、空列表、空元祖、空字典转换为布尔值时均为False
• 其他均为True

3. 字符串（str）

3.1 可变类型和不可变类型

可变数据类型：在python中定义一个变量，当变量值被修改后，内存地址没有改变，则该数据定义为可变数据类型。（可以用id来查看）

不可变数据类型：当变量的值被修改后，变量的内存地址发生变更（创建了新对象），则认为该类型为不可变数据类型。

3.2 字符串处理的相关方法

1）大小写相关，得到的都是一个新的字符串

• swapcase()
• upper()
• lower()
• casefold()
• title()
• capitalize()

2）开头结尾字符判断，得到一个布尔值

• endswith()
• startswith()

3）去除字符串两边的内容，得到一个新的字符串

• strip()

4）查找统计

• find()
• index()
• count()
• len()

5）替换分割

• replace()
• partition()
• split()，字符串切割，得到的是一个列表
• splitlines()
• join()

6）类型判断，返回布尔值

• isdigit()
• isalpha()
• isalnum()
• isspace()

7）其他

• expandtabs(15)
• range(0,20,2)

3.3 字符串处理代码示例代码

name = "   hgAlexHgzero 
 wuzhihao   "

print("大小写转换效果：")
print(name.capitalize())                  # 首字母大写
print(name.swapcase())                    # 将字符串中的大小写互换
print(name.title())                       # 字符串中的每个单词首字母大写
print(name.upper())                       # 全部变大写
print(name.lower())                       # 全部变小写,只能转换26个英文字母
print(name.casefold())                    # 更为牛逼的全部变小写,不光支持26个英文字母，还支持其他非字母
print("*"*80)

print("判断开头结尾：")
print(name.endswith("zero"))              # 判断是否以zero字符串结尾
print(name.startswith("hg"))              # 判断是否以hg字符串开头
print("*"*80)

print("strip效果：")
print(name.strip())                       # 剔除字符串两端的空白
print(name.rstrip())                      # 剔除字符串右边的空白
print(name.lstrip())                      #剔除字符串左边的空白
print("*"*80)

print("查找find和index ：")
print(name.find("A"))                     # 查找A，返回其索引，若找不到，则返回-1
 # index 和 find 都有从左和从右开始找的方法，rfind() lfind()  rindex() lindex()
print("index为：",name.index("A"))        # 返回字符串的索引值，若找不到则返回错误

print("统计数量")
name.count("hgzero",3,9)                  # 在3到9的位置计数hgzero出现的次数
print("*"*80)

print("特殊效果：")
print(name.center(50,"*"))                # 将字符串放于50个字符内容的中间，其他空缺内容用*符号补充
print(name.ljust(20,"-"))                 # 占用20个字符串空位，name字符串靠左，未填满则用-补充
print(name.rjust(20,"-"))                 # 与ljust类似，name字符串靠右
print(name.zfill(20))                     # 占用20个字符串空位，name字符串未占用的空位则在前面补0
print("*"*80)

print("replace效果：")
print(name.replace("zero","Wuzhihao"))    # 用第二个参数来替换第一个参数，但是不会改变原来的字符串，只作为一次结果
# replace()的第三个参数表示要替换的次数,若不指定则表示替换所有
print("*" * 80)                           # 可用变量来接受这一次的结果

print("partition效果：")
print(name.partition("zero"))             # 以zero将整个字符串分成3部分   zero前，zero，zero后   保存为列表
print("*"*80)

print("split效果：")
print(name.split("H"))                    # 按照H字符将整个字符串进行切割，切割后H字符消失，切割后内容保存为列表形式
print(name.splitlines())                  # 按照行分隔，返回一个包含各行作为元素的列表，按换行来切割
print("*"*80)
# 注意，split()不加参数默认以空格切割，加参数不能为空，就是说貌似split不能对asdfadf这样的字符串进行每个字符的切割

print("join效果：")
b = "-"
print(b.join(name))                       # 将字符串b 插入到字符串变量name中的每个字符之间，形成一个新的字符串
print("*".join(name))
print("*"*80)

print("字符串类型判断：")
print(name.isdigit())                     # 判断所有字符是否是字符
print(name.isalpha())                     # 判断所有字符是否为字母
print(name.isalnum())                     # 判断所有字符是否为数字和字母的组合
print(name.isspace())                     # 判断是否为纯空格
print("*"*80)

print("expandtabs方法的使用：")
like = "name:wuzhihao	age:20	addr:China	"
print(like.expandtabs(15))               # 每次以15个字符位为一单位，直至出现	 ，每一单位中的除了字符串的空白位用空格填充

print("    7个基本魔法：join() , split() , find() , strip() , lower() , upper() , replace()   ")
print("
"*3)

love = "I love you forever"
print(len(love))                          # 获取字符串的长度
print(love[4])                            # 通过下标的方法截取字符串
print(love[2:6])                          # 通过切片的方式截取字符串

print("range方法")
print(range(0, 20, 2))                      # 以2为步长(每隔一个数)，打印在0到20的范围内(不包括20)的值
# python2中range方法立即创建，而python3中range只在要循环迭代的时候才创建

3.4 字符串的其他内容

1）字符串拼接

2）字符串格式化

4. 列表（list）

4.1 列表类型说明

列表为可变数据类型，且列表是有序的。

• 可变数据类型（mutable）：列表、字典、集合。
• 不可变数据类型（unmutable）：数字、字符串、元组。

可迭代对象：字符串、列表、元组、字典、集合。

4.2 列表的常用方法

1）切片

• name[0:4]，name[0:4:2]，name[:4]，name[1:]，name[:-1]

2）增加

• append()
• insert()

3）扩展

• extend()

4）删除

• del  name[2]
• remove()
• pop()

5）修改

• name[2]='two'
• name[3:6]=['first','second','third']

6）查找、统计

• index()
• count()

7）排序、翻转

• sort()
• reverse()

8）深浅copy（要导入copy模块）

• copy()
• deepcopy()

4.3 深浅copy

1）浅拷贝

对可变对象而言，对象的值一样可能包含有其他对象的引用；浅拷贝产生新的对象，虽然具有完全不同的id，但是其值若包含可变对象，这些对象和原始对象中的值包含同样的引用。

也就是说，浅拷贝只拷贝了一层，若子层内还有其他引用，则只拷贝引用的链接。

2）深拷贝

深拷贝不仅仅拷贝了原始对象自身，也对其包含的值进行拷贝，它会递归的查找对象中包含的其他对象的应用，来完成更深层次拷贝。

深拷贝产生的副本可以随意修改而不需要担心引起原始值的改变。

import copy

a = copy.copy(b)      # 对b进行浅copy后赋值给a，浅拷贝
c = copy.deepcopy(d)  # 深拷贝

# copy.copy()  浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象。
# copy.deepcopy()  深拷贝 拷贝对象及其子对象

v = names.copy()
print(v)

4.4 列表常用方法示例代码

names = ['hgzero', 'wuzhihao', 'zero', 'wuzhihao', 'hg', 'hao']

print("切片操作")
print(names[0:4])                        # 列表的切片操作不包括最后一个值
print(names[0:4:2])                      # 切片的第三个参数代表 每隔1个数取一个值
print(names[:4])
print(names[1:])
print(names[:-1])                        # 取值不包括最后一个值
print("#" * 50)

print("三种增加的方法：")
print("追加")
names.append("wu")                       # 在列表尾部追加
names.append("zhi")
names.append("hao")
print(names)
print("插入")
names.insert(2, "插入的值")              # 在2索引的位置插入要添加的值
print(names)
print("扩展")
b = [1, 2, 3, 5, 9, 7, 8]
names.extend(b)                         # 将b列表合并到names列表中（尾部添加），形成一个新的列表
print(names)

print("三种删除的方法")
del names[2]
del names[3:5]
print(names)
names.remove("hgzero")                  # 删除指定的元素
print(names)
names.pop()                             # 删除列表的最后一个值并返回删除的值，也可加上参数表示删除指定的索引的值并返回删除的值
print(names)

print("修改")
names[2] = "修改的值"
names[3:6] = ["first", "second", "thrid"]    # 批量修改
print(names)

print("获取下标")
print(names.index("wuzhihao"))          # 只返回找到的第一个下标

print("统计")
print(names.count("wuzhihao"))

print("排序和翻转")
b.sort()     # 排序
print(b)
b.reverse()  # 反转
print(b)print("清空")
names.clear()
print(names)

5. 元组（tuple）

5.1 元组类型说明

元组和列表差不多，但是元组一旦创建，就不能再修改（增加、修改、删除），所以元组又叫只读列表。

元组不能修改的只是元组的一级元素，但是一级元素中的内容可以修改。

• 元组的末尾最好加上一个逗号。
• 元组为可迭代对象，所以可以被迭代方法进行迭代处理。
• 元组是有序的。

5.2 元组的处理

1）元组和列表的转换

ls = list(names)   # 转换为列表
print(ls)
tu = tuple(ls)     # 转换为元组
print(tu)

2）切片：和列表一样

3）方法：

• len()
• count()
• index()

5.3 元组常用方法示例代码

# 元组和列表差不多，但是元组一旦创建，便不能再修改(增加、修改、删除)，所以又叫只读列表
# 元组和列表可以互换   list()   tuple()

# 元组的末尾最好加上一个逗号
names = ("hgzero","wuzhihao","zero","wuzhihao",)
(hgzero,)

print("元组的切片")
print(names[1:3])

print("元组和列表的转换")
ls = list(names)
print(ls)
tu = tuple(ls)
print(tu)

print("元组只有2个查的方法，一个是count，另一个是index")
print(names.count("wuzhihao"))
print(names.index("zero"))

print("元组为可迭代对象")
print("*".join(names))         # 当元组中全部为字符串时，可以用join方法来转换

print("元组是有序的")
tu = (111,"alex",(11,22),[(33,44)],True,33,55)
print(tu[3][0][0])

print("元组的不能修改只是针对元组的一级元素,但一级元素中的内容可用修改")
tu[3][0]="wuzhihao"
print(tu)

6. 字典（dict）

 6.1 字典类型说明

字典存储为键值对形式，且字典是无序的。

字典的键（key）必须是唯一的

• key必须可哈希，且key必须为不可变数据类型；
• 布尔值可以作为字典的key；

6.2 字典的处理方法

1）获取所有的键&值

• xx_dick.keys()       返回为一个高仿列表；
• xx_dick.values()    返回为一个高仿列表；
• xx_dick.items()      获取字典中所有的键、值，返回为一个个元组，包含在一个高仿列表中；

2）增加&修改&更新

• info['stu4'] = 'hgzero'
• info['stu4']='Tom'
• update({"name": "hgzero", "age": 18})

3）删除

• del info['stu4']
• pop('stu4')

4）查找

• 'stu1' in info
• get()
• info['stu1']

5）其他

• setdefault()

6.3 字典使用示例代码

# 字典存储为 键值对 形式
# 字典dick  是无序的
info = {
    "stu1": "hg zero",
    "stu2": "wu zhihao",
    "stu3": "hao wu",
}

print("增加：")
info['stu4'] = "wuzhihao"
print(info)

print("字典的扩展：")
b = {"A": 1, "B": 2, "C": 3}
info.update(b)                         # 将b字典中的内容扩展到info中
print(info)
info.update(k1=123, k2=456, k3=789)    # update() 也支持在括号中直接使用=进行键值对赋值，其会自动转换成字典的形式，类似**kwargs
print(info)

print("删除(两种)：")
info.pop("stu4")                       # pop() 可传入第二个参数(默认值)，表示若没有指定的key，则返回默认值
print(info)
del info["stu3"]
print(info)

print("修改：")
info['stu4'] = "Tom"
print(info)

print("查找(三种)：")
print("stu1" in info)                  # 判断名为stu1的键是否在info字典中
print(info.get("stu2"))                # 获取字典中键为stu2的值
print(info.get("stu9"))                # 若要获取的键在字典中不存在，则返回None
print(info["stu2"])                    # 这样获取对应键的值，若字典中不存在则会报错


print("字典中的其他方法：")
print(info.values())                   # 获取字典中的所有的值
print(info.keys())                     # 获取字典中的所有的键  键和值都可用用for循环来打印出来
print(info.items())                    # 获取字典中的所有的键和值

info.setdefault("stu7", "Alex")        # 设置默认的键值对
print(info)

v = dict.fromkeys([1, 2, 3, 4], "hgzero")  # 构建一个字典，将第一个参数迭代为key ， 第二个参数为每个key的value
print(v)


print("字典的循环：")
for key in info:
    print(key, info[key])

for k, v in info.items():              # 会先把dict字典转换为list列表，数据量大时不用
    print(k, v)

7. 集合

7.1 集合类型说明

1）集合的特点

• 子元素不重复：具有天生去重性（将一个列表转换成集合，就自动去重了）；
• 子元素必须可哈希：集合是可变类型，但是不能修改，只能增加或者删除；
• 集合是无序的；

2）注意

• 集合中没有提供 索引、切片、步长 这些功能，且无法使用索引操作；
• 集合可以通过 len() 函数获取长度，也可以通过for循环来取值；

7.2 集合的三种定义方式

a = {3, 6, 4, 7, 8}          

s = set([3, 5, 9, 10, 2])      # 可用set()方法来生成集合, 生成了集合 {3,5,9,10,2}
s2 = set("Hello")              # 这样会生成包含这个字符串中每个字母的集合

f = frozenset({2, 3, 5, 6, 7}) # 此处定义了一个不可变类型的集合，不可增加或者删除其中的值

7.3 集合的处理方法

1）添加

• add()
• update()

2）删除

• pop()
• remove()
• discard()

3）拷贝&清空

• copy()
• clear()

4）存在判断

• in
• not in

5）集合中的交、并、差、对称差 集

• |，&，-，^

6）集合关系的判断

• isdisjoint()
• issubset()
• issuperset()

7.4 集合的转换

其他类型如果想要转换为集合类型，可以通过set进行转换，并且如果数据有重复会自动剔除（自动去重）。

int、str、tuple、dict 都可以转换为集合。

v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) 
# 结果为：{11,22,33,3,99}

v1 = "傻XCCP"
v2 = set(v1)
print(v2) 
# 结果为：{"傻","X","C","C","P"}

v1 = (11,22,3,11)
v2 = set(v1)
print(v2) 
# 结果为：{11,22,3}

v1 = {"age":12, "status":True,"name":"傻X"}
print( set(v1.keys()) )    # 输出：{'status', 'name', 'age'}
print( set(v1.values()) )  # 输出：{'status', 'name', 'age'}
print( set(v1.items()) )   # 输出：{('age', 12), ('status', True), ('name', '傻X')}

7.5 集合常用方法示例代码

# 集合：去重性 ，  将一个列表转换成集合，就自动去重了
# 集合是无序的
# 集合是可变类型，但是不能修改，只能增加或者删除

a = {3, 6, 4, 7, 8}          # 定义集合的方式
s = set([3, 5, 9, 10, 2])    # 可用set()方法来生成集合, 生成了集合 {3,5,9,10,2}
s2 = set("Hello")      # 这样会生成包含这个字符串中每个字母的集合


print("定义一个不可变类型的集合:")
f = frozenset({2, 3, 5, 6, 7})    # 此处定义了一个不可变类型的集合，不可增加或者删除其中的值
print(f)
for i in f:
    print(i)

print("添加(两种)：")
s.add("x")                   # 添加一项，且一次只能添加一个值
s.update([12, 45, 77])       # 添加多项，可以传进各种可迭代对象，统一迭代添加到集合中
s.update(s2)                 # 更新
print(s)

print("删除(三种)：")
s.pop()                      # 因为集合是无序的，所以pop()是随机删除
s.remove("H")                # 删除一项，若不存在会报错
s.discard("e")               # 若不存在不会报错
print(s)

print("拷贝：")
b = a.copy()
print(b)

print("清空：")
a.clear()
print(a)

print("判断:")
print(2 in s)                # 判断2是否在s集合中
print(2 not in s)

print("获取集合的长度：")
print(len(s))                # 获取集合的长度


print("集合中的交、并、差、对称差  集：")
# a = s | s2                 # 两者之间的并集
x = a.union(s2)

# b = s & s2                 # 两者之间的交集
y = s.intersection(s2)

# c = s - s2                 # 差集 （在s中，但不在s2中）
z = s.difference(s2)

# d = s ^ s2                 # 对称差集 （在s或s2中，但不会同时出现在二者中）
w = s.symmetric_difference(s2)


print("两个集合之间关系的判断：")
a1 = {1, 2, 3, 4, 5}
a2 = {1, 2, 3, 4, 5, 6, 7, 8}
print(a1.isdisjoint(a2))     # 判断两个集合中是否有交集，如果没有则为True，如果有则为False
print(a1.issubset(a2))       # 判断a1是否为a2的子集，若是则为真，否则为假
print(a1.issuperset(a2))     # 判断a1是否为a2的父集，若是则为真，否则为假