Python基本数据类型int, bool, str,list,tuple,dict

基本数据类型(int, bool, str,list,tuple,dict,set)

一.python基本数据类型

1. int  整数. 主要用来进行数学运算

2. str  字符串, 可以保存少量数据并进行相应的操作,用双引号或单引号或三引号括起来

3. bool 判断真假, True, False

4. list 存储大量数据.用[ ]表示

5. tuple 元组, 不可以发生改变,只读列表 用( )表示

6. dict 字典, 保存键值对, 一样可以保存大量数据{key:value}

7. set 集合, 保存大量数据. 不可以重复. 其实就是不保存value的dict

二. 整数(int)

python3中所有的整数都是int类型. 但在python2中如果数据量比较大. 会使用long类型.

在python3中不存在long类型

整数可以进行的操作:

bit_length(). 计算整数在内存中占用的二进制码的长度

三. 布尔值(bool)

布尔只有两个值. True,False. 一般是没有什么操作的.

类型转换的问题:

想把xx转换成yy. yy(xx)

可以表示False的内容:0, "", [], tuple(), {}, None

所有的空都是False. 所有的非空是True

取值只有True, False. bool值没有操作.

str    int int(str)

int    str str(int)

int    bool bool(int). 0是False 非0是True

bool   int int(bool) True是1, False是0

str     bool bool(str) 空字符串是False, 不空是True

bool    str str(bool) 把bool值转换成相应的"值"

四. 字符串 (str)

字符串,由单引号或双引号或三引号',",''',阔起来的内容就是字符串,字符串是不可变的数据类型.不论你执行任何操作. 源字符串是不会改变的, 每次操作都会返回新字符串

1..字符串相关操作:

  1. upper() 转换成大写
  2. stript() 去掉空白
  3. replace(old, new) 把xxx替换成xxxx
  4. split() 切割. 返回列表. 用多长的刀. 就要损失掉多少
  5. startswith() 判断是否以xxx开头
  6. find(), count(), index()
  7. len()  计算字符串长度. python的内置函数

2. for循环

for 变量 in 可迭代对象:

循环体, 也存在break和continue

else:

当循环结束的时候会执行

3. 切片和索引

3.1索引从0开始, 使用[下标]可以获取到每一个字符, 还可以倒着数,切记索引是从0开始的。

 1 # 012345678
 2 
 3 s1 = "python最牛B"
 4 
 5 print(s1[0]) # 获取第0个
 6 
 7 print(s1[1])
 8 
 9 print(s1[2])
10 
11 print(s1[3])
12 
13 print(s1[4])
14 
15 print(s1[5])
16 
17 print(s1[6])
18 
19 print(s1[7])
20 
21 print(s1[8])
22 
23 print(s1[9]) # 没有9, 越界了,会报错
24 
25 print(s1[-1]) # -1 表示倒数.
26 
27 print(s1[-2]) # 倒数第二个

3.2切片, 我们可以使用下标来截取部分字符串的内容

语法: str[start: end]

切片: [起始位置:结束位置:步长]

规则: 顾头不顾尾, 从start开始截取. 截取到end位置. 但不包括end,默认从左到右取值,当步长为负可以从右往左取值

 1 s2 = "python最牛B"
 2 print(s2[0:3]) # 从0获取到3. 不包含3. 结果: pyt
 3 print(s2[6:8]) # 结果 最牛
 4 print(s2[6:9]) # 最大是8. 但根据顾头不顾腚, 想要取到8必须给9
 5 print(s2[6:10]) # 如果右边已经过了最大值. 相当于获取到最后
 6 print(s2[4:]) # 如果想获取到最后. 那么最后一个值可以不给.
 7 print(s2[-1:-5]) # 从-1 获取到 -5 这样是获取不到任何结果的. 从-1向右数. 你怎么数也数不到-5
 8 print(s2[-5:-1]) # 牛b, 取到数据了. 但是. 顾头不顾尾. 怎么取最后一个呢?
 9 print(s2[-5:]) # 什么都不写就是最后了
10 print(s2[:-1]) # 这个是取到倒数第一个
11 print(s2[:]) # 原样输出

跳着截取

# 跳着取, 步长 
1
s1 = "python最牛B" 2 3 print(s2[1:5:2]) # 从第一个开始取, 取到第5个,每2个取1个, 结果: yh, 分析: 1:5=>ytho => yh 4 5 print(s2[:5:2]) # 从头开始到第五个. 每两个取一个 6 7 print(s2[4::2]) # 从4开始取到最后. 每两个取一个 8 9 print(s2[-5::2]) # 从-5取到最后.每两个取一个 10 11 print(s2[-1:-5]) # -1:-5什么都没有. 因为是从左往右获取的. 12 13 print(s2[-1:-5:-1]) # 步长是-1. 这时就从右往左取值了 14 15 print(s2[-5::-3]) # 从倒数第5个开始. 到最开始. 每3个取一个, 结果oy

步长: 如果是整数, 则从左往右取. 如果是负数. 则从右往左取. 默认是1

切片语法:

str[start:end:step]

start: 起始位置

end: 结束位置

step:步长

4. 字符串的相关操作方法

切记, 字符串是不可变的对象, 所以任何操作对原字符串是不会有任何影响的

1. capitalize大小写转来转去

1 a = "python"
2 
3 a.capitalize()
4 
5 print(a) # 输出发现并没有任何的变化. 因为这里的字符串本身是不会发生改变的. 需要我们重新获取
6 
7 b = a.capitalize()
8 
9 print(b)

2.大小写的转换

 1 a = "python"
 2 
 3 b = a.lower() # 全部转换成小写
 4 
 5 print(b)
 6 
 7 b1 = a.upper() # 全部转换成大写
 8 
 9 print(b1)
10 
11 # 应用, 校验用户输入的验证码是否合法
12 
13 verify_code = "abDe"
14 
15 user_verify_code = input("请输入验证码:")
16 
17 if verify_code.upper() == user_verify_code.upper():
18 
19     print("验证成功")
20 
21 else:
22 
23     print("验证失败")
24 
25 ret = a.swapcase() # 大小写互相转换
26 
27 print(ret)

3.字符串居中

1 a = "Python"
2 
3 b = a.center(10, "*") # 拉长成10, 把原字符串放中间.其余位置补*
4 
5 print(b)

4.更改tab的长度

1 a = "Yong jie\tpython"
2 
3 print(a)
4 
5 print(a.expandtabs()) # 可以改变\t的长度, 默认长度更改为8

5.去空格strip左右两端的空格lstrip去掉左边空格rstrip去掉右边空格

 1 a = " Yong jie haha"
 2 
 3 b= a.strip() # 去掉左右两端的空格
 4 
 5 print(b)
 6 
 7 b1= a.lstrip() # 去掉左边空格
 8 
 9 print(b1)
10 
11 b2= a.rstrip() # 去掉右边空格
12 
13 print(b2)

例题:应用模拟用户登录. 忽略用户输入的空格

 1 username = input("请输入用户名:").strip()
 2 
 3 password = input("请输入密码: ").strip()
 4 
 5 if username == 'YongJie' and password == 'root':
 6 
 7     print("登录成功")
 8 
 9 else:
10 
11     print("登录失败")

指定元素去掉的元素

1 a = "abcdefgabc"
2 
3 print(a.strip("abc")) # defg 也可以指定去掉的元素,

字符串替换

 1 a = "python_C_JAVA_vb_PHP"
 2 
 3 b = a.replace('vb', '') # 把vb替换成牛
 4 
 5 print(a) # "python_C_JAVA_vb_PHP" 切记, 字符串是不可变对象. 所有操作都是产生新字符串返回
 6 
 7 print(b) # "python_C_JAVA_牛_PHP"
 8 b1 = a.replace('y', 'nb', 1) # 把y替换成nb, 替换1个
 9 
10 print(b1) #pnbthon_C_JAVA_vb_PHP

字符串切割

 1 a = 'python,PHP,C,java,css'
 2 
 3 
 4 
 5 b = a.split(",") # 字符串切割, 根据,进行切割切割出来的是列表
 6 
 7 print(b)  #['python', 'PHP', 'C', 'java', 'css']
 8 a1 = """诗人
 9 
10 学者
11 
12 感叹号
13 
14 渣渣"""
15 
16 print(a1.split("\n")) # 用\n切割
17 
18 ['诗人', '', '学者', '', '感叹号', '', '渣渣']

格式化输出

 1 a = "我叫%s, 今年%d岁了, 我喜欢%s" % ('YJ', 19, 'Python') # 第一种写法
 2 
 3 print(a)
 4 
 5 a1 = "我叫{}, 今年{}岁了, 我喜欢{}".format("YJ", 19, "Python") # 按位置格式化
 6 
 7 print(a1)
 8 
 9 a2 = "我叫{0}, 今年{2}岁了, 我喜欢{1}".format("YJ", "Python", 19) # 指定位置
10 
11 print(a2)
12 
13 a3 = "我叫{name}, 今年{age}岁了, 我喜欢{singer}".format(name="YJ", singer=Python", age=19) # 指定关键字,推荐使用这种
14 
15 print(a3)

查找

1 a = "我叫YJ, 我喜欢python, java, c等编程语言"
2 b = a.startswith("YJ") # 判断是否以YJ开头
3 print(b)
4 b1 = a.startswith("我叫YJ") # 判断是否以我叫YJ开头
5 print(b1)
 1 a = "我叫YJ, 我喜欢python, java, c等编程语言"
 2 b2= a.endswith("语言") # 是否以'语言'结尾
 3 
 4 print(b2)
 5 
 6 b3= a.endswith("语言.") # 是否以'语言结尾
 7 
 8 print(b3)
 9 
10 b4= a.count("p") # 查找"p"出现的次数
11 
12 print(b4)
13 
14 b5= a.find("java") # 查找'java'出现的位置
15 
16 print(b5)
17 
18 b6= a.find("我叫YJ") # 查找'我叫YJ'的位置, 如果没有返回-1
19 
20 print(a)
21 
22 b8= a.index("我叫YJ") # 求索引位置. 注意. 如果找不到索引. 程序会报错
23 
24 print(b8)

条件判断

 1 a = "123.16"
 2 
 3 a1 = "abc"
 4 
 5 a2 = "_abc!@"
 6 
 7 # 是否由字母和数字组成
 8 
 9 print(a.isalnum())
10 
11 print(a1.isalnum())
12 
13 print(a2.isalnum())
14 
15 # 是否由字母组成
16 
17 print(a.isalpha())
18 
19 print(a1.isalpha())
20 
21 print(a2.isalpha())
22 
23 # 是否由数字组成, 不包括小数点
24 
25 print(a.isdigit())
26 
27 print(a.isdecimal())
28 
29 print(a.isnumeric()) # 这个比较牛B. 中文都识别.
30 
31 print(a1.isdigit())
32 
33 print(a2.isdigit())

例题:用算法判断某一个字符串是否是小数

 1 a = "-123.12"
 2 
 3 a = a.replace("-", "") # 替换掉负号
 4 
 5 if a.isdigit():
 6 
 7   print("是整数")
 8 
 9 else:
10 
11   if a.count(".") == 1 and not a.startswith(".") and not a.endswith("."):
12 
13     print("是小数")
14 
15   else:
16 
17     print("不是小数")

计算字符串的长度

1 a = "我们不一样,不一样"
2 
3 b = len(a) # 计算字符串的长度
4 
5 print(b)
#注意: len()是python的内置函数所以访问方式也不一样你就记着len()和print()一样就行了

迭代

我们可以使用for循环来便利(获取)字符串中的每一个字符

语法:

for 变量 in 可迭代对象:

pass

可迭代对象: 可以一个一个往外取值的对象

 1 a = "大家好, 我是YJ, 前端的小朋友们,你们好么?"
 2 
 3 # 用while循环
 4 
 5 index = 0
 6 
 7 while index < len(a):
 8 
 9     print(a[index]) # 利用索引切片来完成字符的查找
10 
11     index = index + 1
12 
13 # for循环, 把a中的每一个字符拿出来赋值给前面的c
14 
15 for c in a:
16 
17     print(c)

in有两种用法:

1. 在for中. 是把每一个元素获取到赋值给前面的变量

2. 不在for中. 判断xxx是否出现在str中.

1 a = "大家好, 我是YJ, 前端的小朋友们,你们好么?"
2 
3 print('YJ' in a)  #True

 

例题:计算在字符串"I am YJ, I'm 19years old, I like Python!"

 1 a = "I am YJ, I'm 19years old, I like Python!"
 2 
 3 count = 0
 4 
 5 for c in a:
 6 
 7     if c.isdigit():
 8 
 9         count = count + 1
10 
11 print(count)  #2
list,tuple主要内容:

1. 列表

2. 列表的增删改查

3. 列表的嵌套

4. 元组和元组嵌套

5. range

一. 列表

1. 什么是列表:

列表是一个可变的数据类型, 列表是python的基础数据类型之一,列表由[]来表示, 每一项元素使用逗号隔开. 列表什么都能装. 能装对象的对象,列表可以装大量的数据

lst = [1, 'python', "程序员", [1,8,0,"百度"], ("我","叫", "元", "组"), "abc", {"我叫":"dict字典"},{"我叫集合","集合"}]

列表相比于字符串. 不仅可以存放不同的数据类型. 而且可以存放大量的数据. 32位

python可以存放: 536870912个元素, 64位可以存放: 1152921504606846975个元素.而且列表是有序的(按照你保存的顺序),有索引, 可以切片方便取值.

2. 列表的索引和切片

列表和字符串一样,也有索引和切片,只不过切出来的内容是列表,索引的下标从0开始

列表的索引:

[起始位置:结束位置:步长]

 1 lst = ["python", "Java", "PHP", "C", "VB"]
 2 
 3 print(lst[0]) # 获取第一个元素
 4 
 5 print(lst[1])
 6 
 7 print(lst[2])
 8 
 9 lst[3] = "我很牛" # 注意. 列表是可以发生改变的. 这里和字符串不一样
10 
11 print(lst) # ["python", "Java", "PHP", "我很牛", "VB"]
12 
13 s = "华强北"
14 
15 s[1] = "" #字符串不允许改变会报错
16 print(s)
17 #TypeError: 'str' object does not support item assignment

列表的切片:

 1 lst = ["python", "PHP", "JAVA", "C", "华强北"]
 2 
 3 print(lst[0:3]) # ['python', 'PHP', 'JAVA']
 4 
 5 print(lst[:3]) # ['python', 'PHP', 'JAVA']
 6 
 7 print(lst[1::2]) # ['PHP', 'C'] 也有步长
 8 
 9 print(lst[2::-1]) # ['JAVA', 'PHP', 'python'] 也可以倒着取
10 
11 print(lst[-1:-3:-2]) # 倒着带步长

二. 列表的增删改查

增, 注意, list和str是不一样的. lst可以发生改变. 所以直接就在原来的对象上进行了操作

1. append() 追加

2. insert(index, 元素) 在index位置添加元素

3. extend() 迭代添加

例:append() 追加

1 lst = ["Python", "JAVA", "PHP", "C"]  #定义一个列表
2 
3 print(lst)
4 
5 lst.append("YJ")  #添加YJ元素默认在后面添加
6 
7 print(lst)

例:insert(index, 元素) 追加

 1 lst = []
 2 
 3 while True:
 4 
 5     content = input("请输入你要录入的语言, 输入Q退出:")
 6 
 7     if content.upper() == 'Q':
 8 
 9         break
10 
11     lst.append(content)
12 
13     print("您添加的语言有:",lst)
14 
15 lst = ["Python", "Java", "PHP"]
16 
17 lst.insert(1, "YJ") # 在1的位置插入YJ. 原来的元素向后移动一位
18 
19 print(lst)

例:extend() 迭代添加

1 lst = ["Python", "Java", "PHP"]
2 
3 lst.extend(["YJ", "TX"])
4 
5 print(lst)
#['Python', 'Java', 'PHP', 'YJ', 'TX']

删除

1. pop(index) 按照位置删除元素

2.remove(元素) 直接删除元素

3. clear() 清空列表

4. del 切片

1.pop(index) 按照位置删除元素

 1 lst = ["python", "PHP", "JAVA", "C", "华强北"]
 2 
 3 deleted = lst.pop() # 删除最后一个
 4 
 5 print("被删除的元素是:", deleted)
 6 
 7 print(lst)
 8 
 9 华强北
10 
11 el = lst.pop(2) # 删除2号元素
12 
13 print(el)
14 
15 JAVA
16 
17 print(lst)
18 
19 ['python', 'PHP', 'C', '华强北']

2.remove(元素) 直接删除元素

 1 lst = ["python", "PHP", "JAVA", "C", "华强北"]
 2 
 3 lst.remove("华强北") # 删除指定元素
 4 
 5 print(lst)
 6 
 7 ['python', 'PHP', 'C']
 8 
 9 # lst.remove("YJ") # 删除不存在的元素会报错
10 
11 # print(lst)
12 
13 # ValueError: list.remove(x): x not in list

3. clear() 清空列表

1 lst = ["python", "PHP", "JAVA", "C", "华强北"]
2 
3 lst.clear() # 清空list
4 
5 print(lst)
6 
7 []

4. del 切片.

1 del lst[1:3]
2 
3 print(lst)
4 
5 ['python', 'C', '华强北']

修改

1.索引修改

1 lst = ["python", "PHP", "JAVA", "C", "华强北"]
2 
3 lst[1] = "YJ" # 把1号元素修改成YJ
4 
5 print(lst)
6 
7 ['python', 'YJ', 'JAVA', 'C', '华强北']

2.切片修改

 1 lst = ["python", "PHP", "JAVA", "C", "华强北"]
 2 
 3 lst[1:4] = ["坚持","加油"] 
 4 
 5 print(lst)
 6 
 7 ['python', '坚持', '加油', '华强北']
 8 
 9 lst[1:4] = ["程序员"] 
10 
11 print(lst)
12 
13 ['python', '程序员']

 查询, 列表是一个可迭代对象, 所以可以进行for循环

 1 lst = ["python", "PHP", "JAVA", "C", "华强北"]
 2 
 3 for el in lst:
 4 
 5     print(el)
 6 
 7 python
 8 PHP
 9 JAVA
10 C
11 华强北

其他操作

1.count查询出现的次数

1 lst = ["python", "PHP", "JAVA", "C", "华强北"]
2 
3 c = lst.count("PHP") # 查询PHP出现的次数
4 
5 print(c)
6 
7 1

2.sort() 排序 reverse=True降序

 1 lst = [1, 11, 22, 2]
 2 
 3 lst.sort() # 排序. 默认升序
 4 
 5 print(lst)
 6 
 7 [1, 2, 11, 22]
 8 
 9 lst.sort(reverse=True) # 降序
10 
11 print(lst)
12 
13 [22, 11, 2, 1]

3. reverse() 翻转

1 lst = ["python", "PHP", "JAVA", "C", "华强北"]
2 
3 lst.reverse()
4 
5 print(lst)
6 
7 ['华强北', 'C', 'JAVA', 'PHP', 'python']

4.len() 求长度

1 lst = ["python", "PHP", "JAVA", "C", "华强北"]
2 
3 a = len(lst) # 列表的长度
4 
5 print(a)
6 
7 5

三. 列表的嵌套

采用降维操作.一层一层的看就好.

 1 lst = [1, "太帅", "yJ", ["PYTHON", ["可口可乐"], "雪碧"]]
 2 
 3 # 找到yJ
 4 
 5 print(lst[2])
 6 
 7 YJ
 8 
 9 # 找到太帅和yJ
10 
11 print(lst[1:3])
12 
13 ['太帅', 'yJ']
14 
15 # 找到太帅的帅字
16 
17 print(lst[1][1])
18 
19 20 
21 # 将yJ拿到. 然后首字母大写. 再扔回去
22 
23 s = lst[2]
24 
25 s = s.capitalize()
26 
27 lst[2] = s
28 
29 print(lst)
30 
31 [1, '太帅', 'Yj', ['PYTHON', ['可口可乐'], '雪碧']]
32 
33 # 简写
34 
35 lst[2] = lst[2].capitalize()
36 
37 print(lst)
38 
39 [1, '太帅', 'Yj', ['PYTHON', ['可口可乐'], '雪碧']]
40 
41 # 把太帅换成太丑
42 
43 lst[1] = lst[1].replace("", "")
44 
45 print(lst)
46 
47 [1, '太丑', 'yJ', ['PYTHON', ['可口可乐'], '雪碧']]

四. 元组和元组嵌套

元组: 俗称不可变的列表.又被成为只读列表, 元组也是python的基本数据类型之一, 用小括号括起来, 里面可以放任何数据类型的数据, 查询可以. 循环也可以. 切片也可以. 但就是不能改,如果元祖中只有一个元素就使用这样的格式(元素, )

空元组: tuple()

元祖是一个可迭代对象, 可以使用for循环

 1 tu = (1, "太帅", "YJ", "太牛", "hello")
 2 
 3 print(tu)
 4 
 5 (1, '太帅', 'YJ', '太牛', 'hello')
 6 
 7 print(tu[0])
 8 
 9 1
10 
11 print(tu[2])
12 
13 YJ
14 
15 print(tu[2:5]) # 切片之后还是元组
16 
17 ('YJ', '太牛', 'hello')
18 
19 # for循环遍历元组
20 
21 for el in tu:
22 
23 print(el)
24 
25 1
26 
27 太帅
28 
29 YJ
30 
31 太牛
32 
33 hello

尝试修改元组

 1 tu = (1, "太帅", "YJ", "太牛", "hello")
 2 
 3 # tu[1] = "程序员" # 报错 TypeError: 'tuple' object does not support item assignment
 4 
 5 tu = (1, "哈哈", [], "呵呵")
 6 
 7 print(tu)
 8 
 9 (1, '哈哈', [], '呵呵')
10 
11 # tu[2] = ["fdsaf"] # 这么改不行
12 
13 tu[2].append("青青草原") # 可以改了. 没报错
14 
15 tu[2].append("我最狂")
16 
17 print(tu)
18 
19 (1, '哈哈', ['青青草原', '我最狂'], '呵呵')

关于不可变, 注意: 这里元组的不可变的意思是子元素不可变. 而子元素内部的子元素是可以变, 这取决于子元素是否是可变对象.

元组中如果只有一个元素. 一定要添加一个逗号, 否则就不是元组

1 tu = (1,)
2 
3 print(type(tu))
4 
5 <class 'tuple'>

元组也有count(), index(), len()等方法.

五. range

range可以帮我们获取到一组数据. 通过for循环能够获取到这些数据.

range(n) 从0到n-1

range(m,n) 从m到n-1

range(m,n,q) 从m到n-1 每q个取1个

综上就是切片

 1 for num in range(10):
 2 
 3   print(num)
 4 
 5   0
 6 
 7   1
 8 
 9   2
10 
11   3
12 
13   4
14 
15   5
16 
17   6
18 
19   7
20 
21   8
22 
23   9
 1 for num in range(1, 10, 2):  #隔着来输出步长为2
 2   print(num)
 3 
 4   1
 5 
 6   3
 7 
 8   5
 9 
10   7
11 
12   9
 1 for num in range(10, 1, -2): # 反着来, 和切片一样
 2 
 3   print(num)
 4 
 5   10
 6 
 7   8
 8 
 9   6
10 
11   4
12 
13   2

六 range和for循环来获取列表中的索引

        for i in range(len(列表)):

            i 索引

            列表[i] 元素

七. dict字典主要内容:

1. 字典的简单介绍

2. 字典增删改查和其他操作

3. 字典的嵌套

一. 字典的简单介绍

字典(dict)是python中唯一的一个映射类型.他是以{ }括起来的键值对组成. 在dict中key是唯一的. 在保存的时候, 根据key来计算出一个内存地址. 然后将key-value保存在这个地址中.这种算法被称为hash算法, 所以, 切记, 在dict中存储的key-value中的key'必须是可hash的,如果你搞不懂什么是可哈希, 暂时可以这样记, 可以改变的都是不可哈希的,那么可哈希就意味着不可变. 这个是为了能准确的计算内存地址而规定的.

已知的可哈希(不可变)的数据类型: int, str, tuple, bool

不可哈希(可变)的数据类型: list, dict, set

语法 :{key1: value1, key2: value2....}

注意: key必须是不可变(可哈希)的. value没有要求.可以保存任意类型的数据

创建一个合法字典:

 1 dic = {123: 456, True: 999, "id": 1, "name": 'YJ', "age": 19, "stu": ['帅哥', '美女'], (1, 2, 3): '很666'}
 2 
 3 print(dic[123])
 4 
 5 print(dic[True])
 6 
 7 print(dic['id'])
 8 
 9 print(dic['stu'])
10 
11 print(dic[(1, 2, 3)])

不合法字典如:

1 dic = {[1, 2, 3]: '嘿嘿嘿'} # list是可变的. 不能作为key
2 
3 dic = {{1: 2}: "哈哈哈"} # dict是可变的. 不能作为key
4 
5 dic = {{1, 2, 3}: '呵呵呵'} # set是可变的, 不能作为key

dict保存的数据不是按照我们添加进去的顺序保存的. 是按照hash表的顺序保存的. 而hash表

不是连续的. 所以不能进行切片工作. 它只能通过key来获取dict中的数据

二. 字典的增删改查和其他相关操作

1. 增加

1 dic = {}
2 
3 dic['name'] = 'YJ' # 如果dict中没有出现这个key, 就会新增⼀一个key-value的组合进dict
4 
5 dic['age'] = 19
6 
7 print(dic)

如果dict中没有出现过这个key-value. 可以通过setdefault设置默认值

1 dic.setdefault('Python') # 也可以往里面设置值.
2 
3 dic.setdefault("Guido", "Python") # 如果dict中已经存在了. 那么setdefault将不会起作用
4 
5 print(dic)

2. 删除

 1 dic = {"stu":"hahah"}
 2 a = dic.pop("stu")  #指定键删除
 3 print(dic)
 4 
 5 {}
 6 
 7 del dic["stu"]  #指定键删除
 8 print(dic)
 9 
10 {}

随机删除

 1 ret = dic.popitem() 

清空字典中的所有内容

 1 dic.clear() 

3. 修改

 1 dic = {"id": 123, "name": 'YJ', "age": 19}
 2 
 3 dic1 = {"id": 456, "name": "GUIDO", "ok": "wtf"}
 4 
 5 dic.update(dic1) # 把dic1中的内容更更新到dic中. 如果key重名. 则修改替换. 如果不存在ket,则新增
 6 
 7  8 
 9 print(dic)
10 
11 {'id': 456, 'name': 'GUIDO', 'age': 19, 'ok': 'wtf'}
12 
13 print(dic1)
14 
15 {'id': 456, 'name': 'GUIDO', 'ok': 'wtf'}

在key, 则新增

1 print(dic)
2 
3 {'id': 456, 'name': 'GUIDO', 'age': 19, 'ok': 'wtf'}
4 
5 print(dic1)
6 
7 {'id': 456, 'name': 'GUIDO', 'ok': 'wtf'}

4. 查询

查询一般用key来查找具体的数据.

1 print(dic['name'])
2 
3 # print(dic['sylar']) # 报错
4 
5 print(dic.get("ok"))
6 
7 print(dic.get("sylar")) # None
8 
9 print(dic.get("sylar", "牛B")) # 牛B

5. 其他相关操作

 1 dic = {"id": 123, "name": 'sylar', "age": 18, "ok": "科比"}
 2 
 3 print(dic.keys()) # dict_keys(['id', 'name', 'age', 'ok']) #不用管它是什么当成list来用就行
 4 
 5 for key in dic.keys():
 6 
 7 print(key)
 8 
 9 print(dic.values()) # dict_values([123, 'sylar', 18, '科⽐比']) 一样也当list来用
10 
11 for value in dic.values():
12 
13 print(value)
14 
15 print(dic.items()) # dict_items([('id', 123), ('name', 'sylar'), ('age',
16 
17 18), ('ok', '科比')]) #这个东西也是list. 只不过list中装的是tuple
18 
19 for key, value in dic.items(): # ?? 这个是解构
20 
21 print(key, value)
22 
23 # 解构
24 
25 a, b = 1, 2
26 
27 print(a, b)
28 
29 (c, d) = 3, 4
30 
31 print(c, d)
32 
33 e, f = [1, 2, 3] # 解构的时候注意数量必须匹配
34 
35 print(e, f)

三. 字典的嵌套

 1 dic1 = {
 2 
 3 "name": "YJ",
 4 
 5 "age": 19,
 6 
 7 "language": {
 8 
 9 "name": 'Python',
10 
11 "age": 28
12 
13 }
14 
15 }
16 
17 print(dic1.get("language").get("name"))

七. set集合的内容:

1. 集合的简单介绍

set集合是python的⼀个基本数据类型. 一般不是很常用set中的元素是不重复的无序的里
面的元素必须是可hash的(int, str, tuple,bool), 我们可以这样来记. set就是dict类型的数据但
是不保存value, 只保存key,set也用{}表示

a = {"YJ", "age","19", (1,2,3), "Python"}

 

2.set的特点:
无序, 不重复, 元素必须可哈希(不可变)
作用:
去重复

1 lst = [11,5,4,1,2,5,4,1,25,2,1,4,5,5]
2 a = set(lst)   # 把列表转换成集合. 进行去重复
3 lst = list(a)   # 把集合转换回列表.
4 print(lst)
5 [1, 2, 4, 5, 11, 25]

本身是可变的数据类型有增删改查操作
frozenset()冻结的集合不可变的可哈希的

3.set中的元素是不重复的, 且无序的

1 s = {"JAVA", "JAVA", "Python"}
2 print(s)
3 #结果:{'Python', 'JAVA'}

 

4. 集合增删改查

1.增加

1 a = {"YJ", "age","19", (1,2,3), "Python"}
2 a.add("PHP")
3 print(a)
4 {'YJ', 'Python', 'age', 'PHP', (1, 2, 3), '19'}
5 a.update("VB")  #迭代更新
6 print(a)
7 {'YJ', 'B', '19', 'PHP', (1, 2, 3), 'age', 'Python', 'V'}

2. 删除

 1 a = {"YJ", "age","19", (1,2,3), "Python"}
 2 item = a.pop()  #随机删弹出一个
 3 print(a)
 4 {'19', 'YJ', 'Python', (1, 2, 3)}
 5 a.remove("19")  #直接指定元素删除
 6 print(a)
 7 {'YJ', 'Python', (1, 2, 3)}
 8 #a.remove("哈哈哈")  #删除不存在的元素会报错
 9 a.clear()   #清空set集合
10 print(a)
11 set()

3. 修改

set集合中的数据没有索引也没有办法去定位一个元素所以没有办法进行直接修改.
我们可以采用先删除后添加的方式来完成修改操作

1 a = {"YJ", "age","19", (1,2,3), "JAVA"}
2 #把JAVA改成Python
3 a.remove("JAVA")
4 a.add("Python")
5 print(a)
6 {'age', 'YJ', (1, 2, 3), 'Python', '19'}

4. 查询

set是一个可迭代对象. 所以可以进行for循环

1 a = {"YJ", "age","19", (1,2,3), "JAVA"}
2 for el in a:
3     print(el)
4 19
5 JAVA
6 YJ
7 (1, 2, 3)
8 age

练习:

dic1 = {

'name':['yJ',2,3,5],

'job':'teacher',

'oldboy':{'YJ':['python1','python2',100]}

}

1,将name对应的列表追加一个元素’Python’。

2,将name对应的列表中的yJ首字母大写。

3,oldboy对应的字典加一个键值对’YJ’,’加油’。

4,将oldboy对应的字典中的yJ对应的列表中的python2删除。

2019年11月3日

posted @ 2019-11-03 23:48  YJ同心  阅读(...)  评论(... 编辑 收藏