python基础03基本数据类型

基本数据类型

python基本的数据类型包含6种，分别是：

• 数字，包含整型int，浮点型float,布尔型True/False，不可变类型

• 字符串，str,序列型，用于存储一行字符或者一段文本的，不可变类型

• 列表，list 序列型，用于存储多个变量，可变类型

• 元组,tuple 序列型，用于多个变量表达一个固定组合，不可变类型

• 集合，set 映射型，用于存储多个无序不重复的变量，可变类型

• 字典，dict 映射型，用于存储键值对，可变类型

序列类型就是有顺序的一组数据，可以使用索引

数字

包含整型，浮点型，布尔型，复数型，是一种不可变类型

种类

1. 整数型int：如 1,12，9999,几乎没有限制

2. 浮点型float：如1.0,99.99

3. 布尔型bool

• False 假，除了False外，python中的0 字符串"0"，浮点数0.0 ，空字符串'' 空列表 [] 空元组() 空集合{} 在逻辑判断的是偶都被认为False

• True 真

操作符

• + 加

• - 减

• * 乘

• / 结果为浮点数

• // 整除，舍去所有的小数

• % 取模 3%2=1

• ** 乘方 3**2 = 9

类型转换

• str() 其他类型转换为字符串,str(12)

• int() 字符串整数或浮点数转换为整型 int("12")

• float(): 字符串数字或整型，转换为浮点数 float("1.23")

列表(list,可变类型，序列类型)

一个变量可以保存多个数据

列表操作

方法	说明	示例
append()/insert()/extend()	添加/插入/扩展(连接)	[1,2].append(3)
insert()	插入	[1,3].insert(1,2)
extend()	扩展(连接)	[1,2].extend([3,4])
index()	获取元素索引	[1,2].index(2)
count()	统计元素个数	[1,2,1,1].count(1)
pop()	按索引删除	[1,2].pop(0)
remove()	按元素删除	[1,2].remove(1)
sort()	排序	[1,3,2].sort()
reverse()	反转	[1,3,2].reverse()
len()	查看元素的个数	len(a)

赋值

l1 = [1,"hello world",("123","q")]

获取,直接通过索引进行获取

print(l1[1])

增加

l1.append("qq")  # 直接添加单个数据，添加到末尾

l1.extend(["k8s","openstack",123])  # 添加的是序列类型的，将序列类型里面的数据一个一个的取出来，然后添加到列表的末尾

l1.insert(1,"我是第二个元素")  # 指定索引位置，在索引的前面插入数据
print(l1)



# [1, '我是第二个元素', 'hello world', ('123', 'q'), ['qq'], 'k8s', 'openstack', 123, 'k8s']

删除

l1.pop(1)  # 按照索引删除，无参数的时候，默认删除最后一个

l1.remove("k8s")  # 按照元素进行删除，如果有多个相同的元素，默认删除最先匹配的到的

del l1[0]  # 删除指定的元素

修改

l1[0] = "python"  # 通过索引进行修改

查

for i in l1:  # 遍历列表中的每个元素赋值到i上
    print(i)

列表其他方法

# index 获取元素索引
print(l1.index("qq"))  # 查找qq的索引位置

# sort 排序，没有返回值
l3 = [12,43,12,9,1]
l3.sort()
print(l3)

# sorted() 函数，不修改原列表，会返回一个新的列表
l3 = [12,43,12,9,1]
l4 = sorted(l3)  # 会生成一个新的列表
print(l4)

# reverse() 反转
l3 = [12,43,12,9,1]
l3.reverse()  # 没有返回值，直接对原列表进行反转
print(l3)

案例

统计6000次投掷骰子，每个点数的出现的次数

字符串反转

s="abcdefg"
# reversed() 不会直接返回反转后的字符串，它返回的是一个迭代器（iterator）
print(list(reversed(s)))  # 可以转换为列表，看到里面的真实内容 ['g', 'f', 'e', 'd', 'c', 'b', 'a']

r = "".join(reversed(s))  # 将这些字符串进行拼接， join就是将可迭代对象里面的字符串拼接成一整个字符串
print(r)

# 可迭代对象就是能够被for循环的，被挨个遍历的就是可迭代对象

元组(tuple,不可变类型，序列类型)

1.不可变数据类型，是序列类型(可以支持切片操作)

2.可以存储多种数据类型(列表，字典，字符串)，嵌套

3.只有一个元素的时候，必须加上","号，a=("hello",)，因为python中()有分组的含义，不加"," 会识别为字符串

为什么需要元组?

有时候需要用多个变量来表达一个确定的值，如坐标(x,y)，在哈希算法中，不可变是非常重要的，每次生成的哈希值才能相同的，作为不可变对象，元组可以作为字典的key,{(1,2):3} 是合法的

元组的对象操作方法

由于是不可变的，自带的操作方法非常的少

方法	说明	示例
index()	获取元素的索引	a.index(元素)
count()	获取元素的个数	a.count(元素)

t1 = (12,"99","ask","qqq")
print(t1[1:3])
print(len(t1))
print(t1.count("99"))

t4 = (1,2)
t5 = ("99","ll","mm")
print(t4+t5)  # 输出为(1, 2, '99', 'll', 'mm')

元组中存储的列表可以修改的

t1 = (1,2,["qq",22])

t1[2][1]="99"

print(t1)

# 输出为 (1, 2, ['qq', '99'])

# 但是了，不能直接将整个列表修改为其他的

打包和解包操作

当我们把多个用逗号分隔的值赋给一个变量的时，多个值会打包成一个元组类型；当我们把一个元组赋值给多个变量时，元组会解包成多个值然后分别赋给对应的变量

# 打包操作
t2 = 1,2,"99"
print(t2)  # 输出为(1, 2, '99') 


# 解包操作
x,y,z = t2
print(x,y,z)  # 输出为 1 2 99

元组和列表的比较

python中已经有列表类型，为什么还需要用元组这样的类型呢？

• 元组是不可变类型，不可变类型更适合多线程的环境，因为降低了并发访问量的同步化开销，关于这一点，我们会在后面并发编程详解

• 元组是不可变类型，通常不可变类型在创建的时间上优于对应的可变类型，可以使用timeit函数查看

• 列表和元组之间也是可以互相转换的

# 元组转换为列表
t3 = (1,"99","aa")
print(list(t3))  # 输出为[1, '99', 'aa']

# 列表转换为元组
l1 = [1,"99","aa"]
print(tuple(l1))  # 输出为(1, '99', 'aa')

元组总结

列表和元组都是容器型的数据类型，即一个变量可以保存为多个数据，而且都是按照一定顺序组织元素的有序容器，列表是可变数据类型，元组是不可变数据类型，所以列表可以增，删，改，排序反转，但是这些操作元组是不成立的，列表和元组都支持拼接运算

字符串(str,不可变类型，序列类型)

1.不可变数据类型，是序列类型，可以使用索引

2.不可变就是不能对字符串本身进行修改，修改的话，是得到一个新的字符串

3.字符串的所有方法都有返回值

4.有0个或者多个字符组成的有限序列

字符串的方法

方法	说明	示例
len()	计算字符串的长度	len("as")
count()	查询字符串中某个元素数量	a.count(3)
find(),index()	查找字符串中某个字符第一次出现的索引，find找不到返回-1,index找不到直接报错，	s1.find("123"),s1.index("123")
replace()	替换字符串某部分	s1.replace("old","new")
split()	将字符串按分隔符分隔成列表	s1.split(",") 字符串按照,分割,返回的是一个列表，存储到列表中了
join()	将字符串作为分隔符连接新的字符串	"-".join(["a","b"]) 返回为 a-b
lower()/upper()	将字符串转换为全小写/大写	"AbcdeF".lower()，结果为abcdef , "abcedF".upper()，结果也为ABCDEF
isdigit() / isalpha() / isalnum()	字符串是否纯数字/纯字母/纯数字字母组合	"123".isdigit()，结果为True
strip() / lstrip() / rstrip()	去掉字符串左右/左边/右边的无意字符（包括空格、换行等非显示字符)	" this has blanks \n".strip()，结果为this has balnks

# join方法，按照指定元素拼接一个新的字符串
s1 = "a,d,g"
s2 = "-".join(s1)
print(s2)  # 输出为a-,-d-,-g

s3 = ["1","a","c"]
s4 = "-".join(s3)
print(s4)  # 输出为 1-a-c

# replace方法  replace("old","new","num") num就是替换的次数

s6 = "a,e,r"
s7 = s6.replace(",","--")
print(s7) # 输出为a--e--r

# find方法

s6 = "a,e,r" 
print(s6.find("r"))  # 输出为4


# split方法

s6 = "a,e,r"
s7 = s6.split(",")  # 先将字符串以,分割，然后存储到列表中
print(s7)  # 输出为['a', 'e', 'r']

# strip方法

s1 = "  qwe  "
s2 = s1.strip()  # 默认去掉2边的空格
print(s2)  # 输出为qwe

s1 = "baqweab"
s2 = s1.strip("ab")  # 去掉左右2边的"a" "b"字符
print(s2)  # 输出为qwe

# 切片操作
s1 = "baqweab"
print(s1[1:2])  # 输出为a


# 成员算法，判断字符串是不是在这个里面

in 和 not in

s1 = "hello,world"

s2 = "goodbye,world"

print("wo" in s1)   # 输出为true
print("wo" not in s1)  # 输出为false
print(s2 in s1)  # 输出为false

字符串的运算

比较运算：> < ==(2个等号，判断是否相等) a!=b(a不等于b)

成员运算： in, not in 判断一个元素中是否包含另一个元素

逻辑运算符：and(2边结果都为true,返回一个true),or(只要有一个为true,结果就返回true),not(对结果进行取反，真为假，假为真)

复合运算符：+=，-=，*=

返回的是一个true或者false

字符串格式化

name = "tom"
age = 18
print("我叫{},年龄是{}" .format(name,age))   # fortmat格式

print("我叫%s,年龄是%d" %(name,age))  # %s 站位

print(f"我叫{name},年龄是{age}")  # 最常用的格式化

转义字符

# \t  制表符
# \n  换行符
# \b  退格符，删除前面一个字符
# \r 回车符，前面写的内容就没有了，后面内容就是一个顶格
# \\t 让后面的\t变成普通含义

集合(set，可变类型，散列类型)

集合的定义

特点：

• 可变的数据类型，但是里面的数据是不可变的

• 无序性，每一个元素的地位都是相同的，无序的

• 唯一性，每个元素都是不重复的，唯一的,相同的值会自动的去重

• 可以存储多个类型的数据

• 里面的元素是不可变的，因此集合里面不能存储列表(列表是可变的)，可以存储元组，字符串，这些都是不可变的

set1 = {"ad",123}

set1 = {}  # 这个定义的是一个字典，而不是定义集合
print(set1)
print(type(set1))

# 因此创建一个空集合，使用set()
set2 = set()
print(set2,type(set2))

集合的方法

add() 添加元素

remove() 删除元素，删除集合中存在的元素，否则会报错

discard 删除元素，删除不存在的元素，不会报错

pop() 随机删除集合中的一个元素，有一个返回值，就是哪一个元素被删除了

clear() 清空集合中的所有元素

update() 批量添加多个，添加集合

s1 = {123,"ad","qq"}
s1.add("aa") # 添加一个元素
s1.remove("ad")  # 删除一个元素
s1.pop()  # 随机删除一个元素
s1.discard(123)  # 删除元素
s2 = {"mm","nn"}  

s1.update(s2)  # 添加一个新的集合
print(s1)

字典(dict 可变类型，散列类型)

字典的定义

• 可变的数据类型，key是不可变，key不能重复，value可以是任意的数据类型

• 是散列类型，不能使用索引

• 数据添加的话，那么数据的顺序就发生了变化，索引也就改变了，有没有解决方法呢，就是一个字典

• 里面的每个元素都是以键值对的方式存在的，

d1 = {
    "name":"q",
    "age": 18,
    "sex":"男",
    "number": ["123",888]
}

字典的运算

字典需要用键去索引对应的值，不能通过索引取值，只能通过key来获取值

字典的key是不可变的，int,str,元祖，因此列表，集合不能充当key,因为它是可变的

d1 = {
    "name":"q",
    "age": 18,
    "sex":"男",
    "number": ["123",888]
}

# 索引运算，通过key来修改value值
print(d1["name"])
d1["age"] = "29"
print(d1)

# 成员运算
print("name" in d1)
print("age" not in d1)

# 遍历字典，输出字典的key和value值
for key in d1:
    print(f"{key}\t {d1[key]}")

字典的方法

方法	说明	示例
dict.get(key, default)	获取值，不存在返回 default（默认 None）	d.get('a', 0)
dict.setdefault(key, default)	获取值，不存在则设置并返回 default	d.setdefault('a', [])
dict.update([other])	合并字典或可迭代键值对	d.update({'b': 2})
dict.pop(key[, default])	删除并返回指定键的值	d.pop('a')
dict.popitem()	删除并返回最后插入的键值对（LIFO）	d.popitem()
dict.clear()	清空字典	d.clear()

查找值

d1 = {
    "name":"q",
    "age": 18,
    "sex":"男",
    "number": ["123","456"]
}

# 通过get方法获取值
print(d1.get("name")) # 通过get方法获取对应的value值
print(d1.get("weight",True))  # 不存在key的话，就给一个默认的值

# 通过键获取值
print(d1["name"])

# 想要获取到所有的键，使用keys方法
print(d1.keys())
# 输出为 dict_keys(['name', 'age', 'sex', 'number'])

# 获取到所有的值，使用values方法
print(d1.values())

# 输出为 dict_values(['q', 18, '男', ['123', '456']])

# 获取所有key,value，
print(d1.items())  # 变成一个元组存储key,value

# 输出为 dict_items([('name', 'q'), ('age', 18), ('sex', '男'), ('number', ['123', '456'])])

for k,v in d1.items():  
    print(f"{k}:\t {v}")

添加元素，dict[键] = 值，存在键的话，就修改对应的值

d1 = {
    "name":"q",
    "age": 18,
    "sex":"男",
    "number": ["123","456"]
}

d1["name"] = "www" # 存在name,修改对应的值
print(d1)

d1["weight"] = "90kg" # 不存在，添加这个key,value值
print(d1)

# update方法，实现了2个字典的合并
# 后加入的字典如果key有相同的话，就更新

d2 = {
    "name": "ppp",
    "weight": "99kg"
}

d1.update(d2)
print(d1)

字典的删除 pop(键) 删除是整个键值对 ，有一个返回值，

d1 = {
    "name":"q",
    "age": 18,
    "sex":"男",
    "number": ["123","456"]
}

d1.pop("name") # 通过key删除
print(d1)
d1.popitem()  # 删除的是字典的最后一个key
print(d1)

del 关键字，删除指定的元素

del d1["name"]
print(d1)

清空字典 clear()

d1.clear()

字典的保存

字典有对应的顺序的关系的时候进行保存

个人信息
账号 密码
省份 省会城市

一对多的关系，一个键对应多个值

班级 学生

d3 = {
    17: ["a","b","c"],
    18: ["d","e","f"]
}

# d[17] 得到的是一个列表，往列表里面添加这元素
d3[17].append("g")
print(d3)

字典的嵌套，也就是value里面也存储这个字典更多的情况，用的非常的多

d4 = {
    "data":{
        "count":197,
        "list1":[{"name":"tom","age":18},
               {"name":"jerry","age":19}]
    },
    "age":19

}
print(d4["data"]["list1"][0]["name"])

数据类型的总结

列表：可变的数据类型，可以存储多种类型，可以使用索引，增加，删除，修改都是改变了列表的本身，都是没有返回值的

元组：不可变的数据类型，可以存储多种类型，可以使用索引，不能被修改的

字符串：不可变数据类型，可以使用索引，字符串的方法会得到一个返回值，原字符串不变

集合：可变的数据类型，但是里面的数据是无序的，是不可变的，且唯一性

字典：可变的数据类型，但是key是不可变的类型，value任意类型都可以

序列的相关操作方法

字符串，列表，元组，都是按照顺序存储的变量类型，统称为序列类型，可以使用索引

num1 = [1,2,3,4,5]
# 正向索引，num1[1:4:1]
# 反向索引  num1[-1:-3:-1]

[从谁开始:到谁结束:步长]，这个步长决定方向，取值的话，不会包含这个结束索引

反转取值的

num = [1,2,3,4,5]
print(num[::-1])

# -1反向是从右到左，输出为 5 4 3 2 1

序列类型和散列类型

序列类型：有一定顺序的集合，可以使用索引，切片操作的，字符串，列表，元组，

散列类型：集合，字典，都是不能使用索引，集合是无序的，所以无法使用索引，字典的结构比较特殊

可变类型和不可变类型

最主要的区别就是这个数据能不能被修改

可变类型：原数据可以被修改，列表，集合，字典

不可变类型：原数据不能被修改，修改的话，会产生一个新的数据，字符串，元组，

可迭代对象

可迭代对象：就是能被遍历的，for遍历的就是