Python基础知识笔记（四）

一. 元组（tuple）

      元组——只读列表，数据能被查询，不能修改。字符串的切片操作同样适用于元组。

      一些重要的信息，放在列表中不安全，需要一个容器类的数据类型，创建初衷就是这个原因，比如个人信息，密码等不允许任何人改变。

s = ("ada", "jalksdj", "alkjsd")

# 注意，元组内只有一个值时，必须加个英文符逗号，比如下面也会自动打印出来
print(s[-2:-1])    # ('jalksdj',)

# 格式化输出 %s
 
# 方法一：
msg = "我叫%s, 今年%s, 性别%s" % ("太白", "18", "男"） # 这是一个元组
print(msg)

# 方法二：
dic = {"name": "太白", "sex": "男", "age": 18}
msg = "我叫%(name)s, 今年%(age)s, 性别%(age)s." % dic
print(msg)

二. 列表（list）

      如果只用字符串来存储数据，会有很多问题，比如：

      s = "1 True alex"

      首先， 对s1[2:6]取值，很费劲

      然后对字符串进行的任何操作，取出来的都是字符串类型，不方便。

      再者，字符串有长度限制，只能存储少量的而且是字符串类型的数据。

      因此有了列表这个数据类型，列表中可以存放各种数据类型，比如：

      s = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]

      列表的增删改查操作：

# 列表的增

s = [1,'a','b',2,3,'a']


# insert —— 按照索引增加
s.insert(0, 55)
print(s)     # [55, 1, 'a', 'b', 2, 3, 'a']


# append —— 增加到最后
s.append("aaa")
print(s)     # [55, 1, 'a', 'b', 2, 3, 'a', 'aaa']


# extend —— 迭代的增
s.extend(["q, a, w"])
print(s)     # [55, 1, 'a', 'b', 2, 3, 'a', 'aaa', 'q, a, w']
# 注意这里列表内其实只有一个元素
# 与下面的对比

s.extend('a,b,c')
print(s)     # [55, 1, 'a', 'b', 2, 3, 'a', 'aaa', 'q, a, w', 'a', ',', 'b', ',', 'c']
# 这里通过迭代把字符串里的 5个元素(包括逗号) 都单独加进去了

s.extend("")    # [55, 1, 'a', 'b', 2, 3, 'a', 'aaa', 'q, a, w', 'a', ',', 'b', ',', 'c']
s.extend("  ")  # [55, 1, 'a', 'b', 2, 3, 'a', 'aaa', 'q, a, w', 'a', ',', 'b', ',', 'c', "  "]
# 迭代一个空字符串和一个只含空格的字符串的区别
29
30 # 列表的增中这两种方法结果一样
31 a = [1,2]
32 a[2:] = "as"
33 a.extend("as")
34 # 以上两个都要看字符串里的元素个数，有几个就添加几个进去
35 a[::-1] = "34"  # ['4', '3']
36 # 多一个少一个都会报错
37 a[::-1] = "345"
38 a[::-1] = "3"
39 # 这个也会报错
40 a[::-1] = 34

# 列表的删

# pop() —— 默认删除最后一个值
# 括号里要是添加索引位置数字，则删除指定的元素，有返回值
s = [1, 3, 4, "a", "abc", "12sda"]
s1 = s.pop()
s2 = s.pop(1)

print(s1)    # 12sda
print(s2)    # 3
print(s)      # [1, 4, 'a', 'abc']


# del —— 按照指定位置删除，也可以切片删除，没有返回值
s = [1, 3, 4, "a", "abc", "12sda"]
del s[1]    # [1, 4, 'a', 'abc', '12sda']
del s[:2]   # ['a', 'abc', '12sda']
del s       # 删除整个列表，很少用这个

# remove —— 按照指定元素删除
s = [1, 3, 4, "a", "abc", "12sda"]
s.remove("a")
print(s)    # [1, 3, 4, 'abc', '12sda']


# clear() —— 直接清空整个列表
s = [1, 3, 4, "a", "abc", "12sda"]
s.clear()
print(s)    # []

# 列表的改
# 通过索引号更改对应的值即可，也可使用切片
 
s = [1, "a", "b", 2, 3, "a"]
s[1] = "asd"
print(s)   # [1, 'asd', 'b', 2, 3, 'a']
s[1:3] = [123, "asdjlk"]
print(s)   # [1, 123, 'asdjlk', 2, 3, 'a']


# 如果是单使用切片，则只是把列表里索引号对应的元素删掉，可以加入任何东西，方法和 extend 类似
s = [1, "a", "b", 2, 3, "a"]
s[:3] = ["asj"]    
print(s)    # ['asj', 2, 3, 'a']
s[:3] =[1, 2, ["22", "sad", True]]
print(s)    # [1, 2, ['22', 'sad', True], 'a']

# 如果使用切片加步长，那么添加的元素个数必须与切片删除原列表的个数一样

     还有列表的查：

     索引， 切片， 切片(加步长) 及 for 循环

     列表的其他操作

# count —— 统计某个元素在列表中出现的次数

s = ["q","w","q","r","t","y"]
print(s.count("q"))    #     2

5 s = (1, 3, True)
6 # 这里的 1 和 True 其实是相等的
7 print(s.count(1)) # 2

1 # index —— 从列表中找出某个值第一个匹配项的索引位置
2 # 列表跟字符串不同，不能用 find()，只能用 index()，找不到就报错
3 s = ["q","w","r","t","y"]
4 print(s.index("r"))    # 1
5
6 l1 = ['wusir', "taibai", "ritian", "alex"]
7 # 方法一：通过元素找到其对应的索引号
8 # for i in l1:
9 #     print(l1.index(i))
10
11 # 使用上面的有一个坑，比如列表中有相同的元素时
12 # 使用 index 的话，找到相同元素的第一个元素时就返回索引值了
13 # 后面即使有相同的也不会再返回索引值
14 # l1 = ['wusir', "wusir", "taibai", "ritian", "alex"]
15 # for i in l1:
16 #     print(l1.index(i))
17
18 # 方法二：动态获取列表的元素
19 for index in range(0, len(l1)):
20     print(index)

# sort —— 在原位置对列表进行排序

a = [2,1,3,4,5]
a.sort()     # 他没有返回值，所以只能打印a
print(a)     # [1, 2, 3, 4, 5]
# 还有 sort(reverse=True) 这个反向操作

# reverse —— 将列表中的元素反向存放

a = [2,1,3,4,5]
a.reverse()  # 他没有返回值，所以只能打印a
print(a)       # [5, 4, 3, 1, 2]

# 就目前版本(Python3.6版本及以上)来说，列表可以相加

s1 = [1, 2]
s2 = [1, 2, 3]
ret = s1 + s2
print(ret)    # [1, 2, 1, 2, 3]


# 列表也可以与数字想乘
s3 = [2, 3, 4]
s4 = s3 * 2
print(s4)    # [2, 3, 4, 2, 3, 4]

# 这就类似于字符串的拼接和与数字的相乘

# 在循环一个列表时，最好不要改变列表的长度
# 因为这样会影响列表后面元素的索引位置

# 把下面列表索引为奇数的元素删掉
s = [11, 22, 33, 44, 55]

# 错误方法：
for i in range(len(s)):
    if index % 2 == 1:
        s.pop(index) 

print(s)
# 结果发现是 11, 33, 44，明显有问题

# 正确方法一：

new_li = []
for i in range(len(s)):
    if i % 2 == 0:
        new_li.append(s[i])

s = new_li
print(s)

# 正确方法二：
# 倒叙法 —— 循环删除列表元素
for i in range(len(s)-1, -1, -1):
    if i % 2 == 1:
        s.pop(i)

print(s)
32 
33 # 正确方法三：
34 s[1::2]

# 同理，在循环一个字典时，不能改变字典的大小，否则会报错

# 删除下面字典中 key 中带有 "k" 的键值对
# dic = {'k1':1,'k2':2, 'k3': 3, 'name': '太白'}

# 错误方法：
for key in dic:
    if "k" in key:
        dic.pop(key)


# 正确方法：
l1 = []
for key in dic:
    if "k" in key:
        l1.append(key)

for k1 in l1:
    dic.pop(k1)

print(dic)

三. 字典（dict）

      列表有好处，也有缺点：

      1. 列表如果存储大量的数据，查找速度相对慢一些

      2. 列表存储的数据一般没有什么关联性，比如：

      ["wusir", 175, "男"...]

      单是看这个列表不知道它们之间的联系，因此就有了字典。

      字典相比列表有以下优点：

      查询速度非常快，因为字典是Python中唯一的映射类型，采用键值对（key-value）的形式存储数据。

      字典在3.5及之前的版本中是无序的，但是3.6开始优化机制，字典会按照创建之初的顺序排列。

      Python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。

      可哈希表示key必须是不可变类型，如：数字、字符串、元组，而且这个键是唯一的，后面再写一个到这个位置就会被替换掉。

     dic = {"name": "ss", "name": "a", "name": "sd"}

     print(dic) ==> {"name": "sd"}

　  字典(dictionary)是除列表之外python之中最灵活的内置数据结构类型。

      列表是有序的对象结合，字典是无序的对象集合。

      两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

# 字典的增， 有则覆盖key原来对应的值，无则将键值添加进去

dic = {'age': 18, 'name': 'jin', 'sex': 'male'}

dic.setdefault('k','v')
print(dic)     # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}

# setdefault —— 有则不变，无则添加
# 在字典中添加键值对，如果只有键那对应的值是none.但是如果原字典中存在设置的键值对，则他不会更改或者覆盖。
dic.setdefault('k','v1')  
print(dic)     # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
12 dic.setdefault("high", 175)
13 print(dic)     # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v', 'high': 175}

# 字典的删

# pop() —— 有返回值
dic = {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
dic_pop = dic.pop("age")
print(dic_pop)    # 18
print(dic)           # {'name': 'jin', 'sex': 'male', 'k': 'v'}

# pop根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值
dic_pop2 = dic.pop("a")    # 报错，显示 "KeyError" : "a"
dic_pop2 = dic.pop("a", "无Key返回默认值")
print(dic_pop2)    # 无Key返回默认值
print(dic)            # {'name': 'jin', 'sex': 'male', 'k': 'v'}
# 设置返回值的好处是避免程序报错

# del —— 没有返回值
del dic["name"]     
print(dic)             # {'sex': 'male', 'k': 'v'}


# popitem() —— 随机删除字典中的某个键值对，并将删除的键值对以元组的形式返回
dic = {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
dic_pop3 = dic.popitem()
print(dic_pop3)     # ('k', 'v')
print(dic)          # {'age': 18, 'name': 'jin', 'sex': 'male'}
# 前面提到Python3.5及之前的版本中字典是无序的，所以每次使用 popitem() 随机删除一个键值对
# 但是3.6版本之后就只会删除最后一个，相当于 pop()，多次尝试运行都一样的结果。
# clear() —— 清空字典
dic_clear = dic.clear()
print(dic_clear)     # None
print(dic)           # {}
32 
33 注意：dic.pop(key) 与 dic.popitem() 的区别，前者删除某元素，括号里要加键，而后者只是删除最后一对键值

# 字典的改

dic = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}

# 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中,注意不是 dic1
dic2.update(dic)  
print(dic2)    # {'name': 'jin', 'weight': 75, 'age': 18, 'sex': 'male'}
9  # update 还可以这样用
10 dic.update(weight = 150, high = 175)  # key 不用加引号，也不能是数字, 因为它是一个变量
11
12 # 还有一个最简单的方法，比如
13 dic["age"] = 28

# 字典的查(取值)

dic = {"name":"jin","age":18,"sex":"male"}

value1 = dic["name"]  # 没有会报错
print(value1)    # jin

value2 = dic.get("age")
print(value2)    # 18
# 没有对应的 Key 则返回设定的返回值
value3 = dic.get("djffdsafg","默认返回值")  
print(value3)    # 默认返回值
13
14 # 还可以使用 for...in... 循环字典，获取的是key值

# 字典的其他操作

dic = {"name":"jin","age":18,"sex":"male"}
item = dic.items()
print(item,type(item))  
# dict_items([('name', 'jin'), ('sex', 'male'), ('age', 18)])   <class 'dict_items'>
# 这个类型就是dict_items类型，可迭代的

keys = dic.keys()
print(keys,type(keys))  
# dict_keys(['sex', 'age', 'name'])   <class 'dict_keys'>

values = dic.values()
print(values,type(values))  
# dict_values(['male', 18, 'jin'])     <class 'dict_values'> 

# 字典的循环

dic = {"name":"jin","age":18,"sex":"male"}

for key in dic: # 或者这样写完善点： for key in dic.keys():
    print(key)

for item in dic.items():
    print(item)

for key,value in dic.items():
    print(key,value)　

# 分别赋值

a, b = 10, 20
print(a, b)    # (10 20)

a, b, c = (1, 2, 3)
print(a, b, c) # (1, 2, 3)

a = 50
b = 30
a, b = b, a   # 先看右边，首先 b 指向 30， a 指向 50
print(a, b)   # (30, 50)
13 # 相当于重新赋值

# 字典的四种创建方式

# 第一种
dic = dict(name="alex", age="12")
# 这种方法的值没法是数字
dic = dict({键值对}）

# 第二种
# 直接创建
dic = {键值对}

# 第三种
dict.fromkeys("abc", "alex")
14 # 这里的第一个参数是迭代添加为字典的键，第二个参数为值，默认为 None。
15 # 所以第一个参数就是可迭代对象，比如字符串，列表。
16 
17 # 第四种
18 dic = dict([("a", 1), ("b", 2), ("c", 3)])
19
20 # 拓展
21 l1 = [1, 2, 3]
22 l2 = ["a", "b", "c"]
23 dic = dict(zip(l1, l2

四. 集合（set）  

      集合和字典一样，是无序的。

      集合有一点就是它是不重复的数据集合，它里面的元素是可哈希的(不可变类型)

      但是集合本身是不可哈希（所以集合做不了字典的键）的。

set1 = {1, 2, "ad", [2, "34"]}
print(set1)

# 打印结果会报错，提示列表不可哈希，因为它是可变的

      以下是集合最重要的两点：

　  去重，把一个列表变成集合，就自动去重了。

　  关系测试，测试两组数据之前的交集、差集、并集等关系。

# 集合的创建

set1 = set({1,2,'barry'})
set2 = {1,2,'barry'}

print(set1,set2)    # {1, 2, 'barry'}     {1, 2, 'barry'}

# 集合的增

set1 = {'alex','wusir','ritian','egon','barry'}
set1.add('景女神')
print(set1)    # {'ritian', 'wusir', 'barry', '景女神', 'alex', 'egon'}


#update：迭代着增加，注意看与前面的区别
set1.update('A')
print(set1)    # {'ritian', 'wusir', 'barry', '景女神', 'A', 'alex', 'egon'}

set1.update('老师')
print(set1)    # {'ritian', 'wusir', '师', 'barry', '景女神', 'A', 'alex', '老', 'egon'}

set1.update([1,2,3])
print(set1)    
# {1, 2, 3, 'ritian', 'wusir', '师', 'barry', '景女神', 'A', 'alex', '老', 'egon'}
# 可以看出与列表的迭代的增类似

#  集合的删

set1 = {'alex','wusir','ritian','egon','barry'}

# 删除一个元素
set1.remove('alex')  
print(set1)         # {'ritian', 'wusir', 'barry', 'egon'}

# 随机删除一个元素
set_pop = set1.pop()
print(set_pop)    # ritian
print(set1)         # {'wusir', 'barry', 'egon'}

# 清空集合
set1.clear()  
print(set1)         # set()

# 删除集合
del set1  
print(set1)         # 报错

       集合的其他操作

# 交集（&  或者 intersection）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

print(set1 & set2)                 # {4, 5}
print(set1.intersection(set2))  # {4, 5}


# 反交集 （^ 或者 symmetric_difference）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

print(set1 ^ set2)                                  # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))       # {1, 2, 3, 6, 7, 8}

# 并集 （| 或者 union）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

print(set1 | set2)         # {1, 2, 3, 4, 5, 6, 7,8}
print(set2.union(set1))  # {1, 2, 3, 4, 5, 6, 7,8}

# 差集 （- 或者 difference）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

print(set1 - set2)               # {1, 2, 3}
print(set1.difference(set2))  # {1, 2, 3}

print(set2 - set1)               # {8, 6, 7}
print(set2.difference(set1))  # {8, 6, 7}

# 子集与超集

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

# 这两个相同，都是说明set1是set2子集。
print(set1 < set2)               # True
print(set1.issubset(set2))     # True 


# 这两个相同，都是说明set2是set1超集。
print(set2 > set1)                # True
print(set2.issuperset(set1))   # True

# frozenset —— 不可变集合，让集合变成不可变类型

s = frozenset('barry')

print(s, type(s))
# frozenset({'b', 'y', 'a', 'r'})     <class 'frozenset'>

# 给你两个列表，将它们合并在一起，去重后以新列表的形式打印出来
# 一定要会这种题目！！！
l1 = [1, 2, 3, 4, 5]
l2 = [2, 3, 4, 5, 6]

l3 = l1 + l2
print(l3)      # [1, 2, 3, 4, 5, 2, 3, 4, 5, 6]

new_list = list(set(new_list))
print(new_list, type(new_list))

五. 基础数据类型总结

   按存储空间的占用分（从低到高）

数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

    按存值个数区分

标量／原子类型	数字，字符串，布尔值
容器类型	列表，元组，字典，集合

    按数据类型可变不可变区分——（可变即可哈希）

可变	列表，字典
不可变	数字，字符串，元组，布尔值

    按访问顺序区分

直接访问	数字
顺序访问（序列类型）	字符串，列表，元组
key值访问（映射类型）	字典

  

六. for -- enumerate -- range 的用法

# for 循环 —— 按顺序循环可迭代对象的内容

msg = '老男孩python是全国范围内最好的python培训机构'
for item in msg:
    print(item)


li = ['alex','银角','女神','egon','太白']
for i in li:
    print(i)


dic = {'name':'太白','age':18,'sex':'man'}
for k,v in dic.items():
    print(k,v)

# enumerate —— 枚举
# 对于一个可迭代、可遍历的对象，enumerate 将其组成一个索引序列
# 利用它同时获得索引和值

li = ['alex','银角','女神','egon','太白']

for i in enumerate(li):
    print(i)
# (0, 'alex')
# (1, '银角')
# (2, '女神')
# (3, 'egon')
# (4, '太白')

for index,name in enumerate(li,1):
    print(index,name)
# 1 alex
# 2 银角
# 3 女神
# 4 egon
# 5 太白

# 起始位置默认是0，可更改
for index, name in enumerate(li, 100):  
    print(index, name)
# 100 alex
# 101 银角
# 102 女神
# 103 egon
# 104 太白　

# range —— 指定范围，生成指定数字,可当作自制一个可控范围的数字列表，也就是说它不是列表

for i in range(1,10):
    print(i)

for i in range(1,10,2):  # 步长
    print(i)

for i in range(10,1,-2): # 反向步长
    print(i)

# 打印一个乘法口诀表

for i in range(1, 10):
    for j in range(1, i + 1):
        # print(str(i) + "x" + str(j) + "=" + str(i * j), end="	")
        print("%dx%d=%d" %(i, j, i*j), end="	")
    print()
 
# end="	" 使用制表符，表示对齐
# 注意print()默认跳到下一行
# 所以这里的 print() 相当于 print("", end="
")

# 1x1=1    
# 2x1=2    2x2=4    
# 3x1=3    3x2=6     3x3=9    
# 4x1=4    4x2=8     4x3=12    4x4=16    
# 5x1=5    5x2=10    5x3=15    5x4=20    5x5=25    
# 6x1=6    6x2=12    6x3=18    6x4=24    6x5=30    6x6=36    
# ...