python学习笔记 数据类型之集合、序列类型（字符串、列表、元祖）、字典

---

集合 set

• 大括号内用逗号隔开多个元素

• 集合(哈希表)是无序的

• 去重

    s1 = {123, "xucheng", 789, 6654,123}
    print(s1)   # 输出 {123, 789, 6654, 'xucheng'}

• 所有(iterable)序列类型都可以放到集合中

  s2 = set('baba')
  print(s2) # 输出 {'b', 'a'}
  s3 = set(['1', 2, 3]) 
  print(s3)     # 输出 {3, 2, '1'}

• 集合和集合之间会有:

  交集 & 并集 | 补集 ^ 差集 -

  s1 = {"xucheng", 22, "男", "淮南师范学院"}
  s2 = {"chenyuhang", 21, "女", "淮南师范学院"}
  print(s1 & s2)    # 输出 {'淮南师范学院'}
  print(s1 | s2)    # 输出 {'淮南师范学院', 21, 22, '女', 'chenyuhang', '男', 'xucheng'}
  print(s1 ^ s2)    # 输出 {21, '女', 22, 'chenyuhang', '男', 'xucheng'}
  print(s1 - s2)    # 输出 {'xucheng', '男', 22}

• 集合的内置方法

  方法:

  1. 优先掌握
     1. 去重
     2. 并集 |
     3. 交集 &
     4. 差集 -
     5. 补集 ^
     6. 父集 >&emsp；>=
     7. 子集 <&emsp；<=
     8. ==
  2. 需要掌握
     1. add：添加元素
     2. difference_update：更新该集合没有的元素
     3. isdisjoint：如果两个元素交集为空返回True，否则返回False
     4. remove：移除元素 # 值不存在会报错
     5. discard ：移除元素 # 不会报错

  # 添加
  s1 = {"xucheng", 22, "男", "淮南师范学院"}
  s1.add("计算机科学与技术")  # 添加
  print(s1)

  # 删除
  s1.remove(3)  # remove丢掉的是没有的则报错
  print(s1)
  
  s1.discard(3)   # discard丢掉的是没有的不报错  推荐用这个
  print(s1)

  # 清除
  temp.clear()    # 清空集合内容
  print(temp)

---

序列类型 （字符串/列表/元祖）

• 序列:序号 列

  索引：012345678

• 序列类型,就是带有索引的数据类型:字符串/列表/元祖

  name = 'xucheng'
  #       0123456
  name1 = name[0]       # 取索引为0的那一位

• 字符串/列表/元组共有方法

  print('len(name):',len(name))   # 长度
  print('wo' in name)     # 字符是否在name变量里
  print('w' not in name)  # 字符是否不在name变量里
  for i in name:      # （根据索引）循环打印字符串name
      print(i)

字符串类型

• ' ' 单引号 和 “ “ 双引号 和 ‘’‘ ’‘’ 三引号 都可以表示字符串

name = 'xucheng'  # 单引号形式
print(name)

name = "xucheng"  # 双引号形式
print(name)

poem = '''锄禾日当午，汗滴禾下土；
谁知盘中餐，粒粒皆辛苦'''
print(poem)        # 三引号中的字符串可以换行

• 如果字符串中需要单引号，则需要用双引号包裹字符串。也可以使用转义符

print("xucheng's name is xucheng")

print('''xucheng's name is "xucheng"''')

• 转义符

本来'表示字符串结束了，但是加上\表示这个’只是一个很普通额字符

print('xucheng\'s name is "xucheng"')

• 打印格式
  1. \t 空4格
  2. \n 换行
  3. r+字符串 原生字符串
  4. \r 原位打印

print('\tnick handsome')    # \t 表示4个空格，缩进

print('锄禾日当午，汗滴禾下土；\n谁知盘中餐，粒粒皆辛苦') # \n 表示换行

print(r'\t\n')  # r+字符串  表示原生字符串

for i in range(5):
     print('\r1',end='')  # end控制输出的形式  # \r原位打印

• 字符串的运算

 print('nick'+' handsome')      # 字符串连接
 print('nick'*50)               # 字符串相乘

字符串处理函数

一些以函数形式提供的字符串处理功能

函数及使用	描述
len(x)	长度，返回字符串x的长度：len("一二三456") 结果为 6
str(x)	任意类型x所对应的字符串形式：str(1.23)结果为"1.23" str([1,2])结果为"[1,2]"
hex(x) 或 oct(x)	整数x的十六进制或八进制小写形式字符串：hex(425)结果为"0x1a9" oct(425)结果为"0o651"
chr(u)	x为Unicode编码，返回其对应的字符
ord(x)	x为字符，返回其对应的Unicode编码

• 字符串内置方法

1. 优先掌握
   1. 索引取值
   2. 切片
   3. 长度
   4. 切分split
   5. 除两边空白strip
   6. 成员运算in&emsp；not in
   7. for循环
2. 需要掌握
   1. lstrip/rstrip：左/右除空白
   2. rsplit：从右开始切割
   3. upper/lower：大写/小写
   4. startstwith/endswith：以某开头/以某结尾
   5. join：连接列表为字符串
   6. replace：替换字符
   7. isdigit：判断是否为数字

一些以方法形式提供的字符串处理功能

方法及使用	描述
str.lower() 或 str.upper()	返回字符串的副本，全部字符小写/大写："AbCdEfGh".lower() 结果为 "abcdefgh"
str.split(sep=None)	返回一个列表，由str根据sep被分隔的部分组成 ："A,B,C".split(",") 结果为['A','B','C']
str.count(sub)	返回子串sub在str中出现的次数："a apple a day".count("a") 结果为 4
str.replace(old, new)	返回字符串str副本，所有old子串被替换为new ："python".replace("n","n456") 结果为 "python456"
str.center(width[,fillchar])	字符串str根据宽度width居中，fillchar可选："python".center(20,"=") 结果为 '=======python======='
str.strip(chars)	从str中去掉在其左侧和右侧chars中列出的字符："= python= ".strip(" =np") 结果为

• 字符串类型的格式化

格式化是对字符串进行格式表达的方式

• 字符串格式化使用.format()方法，用法如下：<模板字符串>.format(<逗号分隔的参数>)
• 字符串格式化使用f-string方法，用法如下：f<模板{<逗号分隔的参数>}字符串>

print(s1+' '+s2+' '+s3+' '+str(s4))   # 太麻烦

# 使用.format()方法
print('{} {} {} {}'.format(s1,s3,s2,s4))  # {}会占用变量名的值，并且数字会转成字符串
# 使用f-string方法
print(f'{s1} {s3} {s2} {s4}')  # {}会占用变量名的值，并且数字会转成字符串

{ ： }

:				<,>	<.精度>
引导符号	用于填充的单个字符	< 左对齐 > 右对齐 ^ 居中对齐	槽设定的输出宽度	数字的千位分隔符	浮点数小数 或 字符串最大输出长度	整数类型 b,c,d,o,x,X 浮点数类型e,E,f,%

s = 'nick'
print(f'{s:*<10}')  # :表示后面的字符有意义，*表示填充的字符，^中间；<居左；>居右，10表示填充的字符长度

height = 180.01
print(f'{height:.3f}')  # .精度

---

列表

• 中括号内用逗号隔开多个元素

• 有序

• 不会去重

  lt = ['xucheng','handsome','chenyuxing','beautiful',1,1,1,1]
  print(lt) # 输出 ['xucheng', 'handsome', 'chenyuxing', 'beautiful', 1, 1, 1, 1]

• 列表和集合相互转换

  s = set(lt) # 列表转成集合类型 就会有集合的特性，如去重，乱序
  lt = list(s)  # 集合转成列表类型
  print(lt) # 输出 [1, 'beautiful', 'xucheng', 'handsome', 'chenyuxing']

• 列表类型的内置方法

  方法:

  1. 优先掌握
     1. 索引取值(即可取又可改)
     2. 切片
     3. 长度
     4. append
     5. 成员运算
     6. for循环
  2. 需要掌握
     1. count：元素个数计数
     2. remove：移除元素
     3. reverse：反转列表
     4. pop：删除元素
     5. insert：插入元素
     6. sort：列表排序
     7. index：索引元素
     8. del：删除元素
     9. extend：扩展列表
     10. clear：清除列表

  # 追加
  lt.append('hhh')    # 追加在末尾
  print(lt) # 输出 [1, 'beautiful', 'xucheng', 'handsome', 'chenyuxing', 'hhh']
  
  # 删除
  del lt[0]   # 按照索引删除,不返回删除值
  print(lt) # 输出 ['beautiful', 'xucheng', 'handsome', 'chenyuxing', 'hhh']
  
  print(lt.pop(0))  # 按照索引删除，返回删除值  # 输出 beautiful
  print(lt)         # 输出 ['xucheng', 'handsome', 'chenyuxing', 'hhh']
  
  # 拷贝
  lt2 = lt.copy() 
  
  # 清除
  lt2.clear()  
  print(lt2)    # 输出 []
  
  # 排序
  lt = [1,3,2,100,4,5]
  lt.sort() # 从小到大排序，正排序
  print(lt) # 输出 [1, 2, 3, 4, 5, 100]
  
  lt.reverse()
  print(lt) # 输出 [100, 5, 4, 3, 2, 1]

• 列表sort排序的另一种用法

  • 根据key值进行排序

  # sort根据key值进行排序
  list = [('曹操', 101), ('刘备', 200), ('阿斗', 3), ('司马炎', 30), ('董卓', 50),('大小乔',100)] # 声明列表
  print(type(list))   # list类型
  for i in list:
      print(i,type(i))    # 列表中的各个元素都是 元祖类型
  # 如果自己写个排序算法,无论如何都是要把里面的值取出来一次的
  def func(i): # ('曹操', 101)  # ('刘备', 200)
      return i[1]     # 101,200  取元祖中的值
  list.sort(key=func) # key=一个取值函数  
  print(list)

---

元组

• 元组就是把列表的中括号换成小括号

• 它没有内置方法

  # 只可取不可更改
  tu  =  (1,3,2,100,4,5)
  print(tu[0])

---

字典类型(键值对)

• 大括号内以逗号分隔键值对(key(描述意义):value)的形式存储数据
• 无序

items = {"name":"xucheng", "age":22, "gender":"男", "hobby_list":["swimming","play"]}
dic = dict()    # 定义字典
print(items)    # 输出定义字典的全部信息
print(dic)

• 字典类型的内置方法

  1 方法

  1. 优先掌握
     1. 按键取值
     2. 长度
     3. keys/values/items
     4. for循环
     5. 成员运算
  2. 需要掌握
     1. pop：删除元素
     2. fromkeys：由一个列表生成一个字典，默认值为None
     3. setdefault：有指定key不会改变值；无指定key则改变值
     4. get：通过key获取value，无key默认获取None
     5. update：扩展字典
     6. del：删除字典键值对

  # 取值
  print(items["name"])    # 按照字典中的key，取出value
  print(items["hobby_list"][0])    # 按照字典中的key，取出第0个value
  
  # get方法取值 ： 如果没有key, 则取None, 也可以自定义没有值能取到的值
  print(items.get("name"))    # 输出 value
  print(items.get('name1'))     # 输出 None
  print(items.get("name1","chenyx"))  # 输出 自定义的value
  
  # 循环取值
  for i in items:     # 默认取得都是字典中的 key
      print(i)
  
  for i in items.values():     # 取出字典中的value
      print(i)
  
  for i in items.items():     # 取出字典中的 键值对(key,value)
      print(i)
  
  # 添加
  items.setdefault("name1","cyx") # 添加(key,value)
  print(items)
  
  # 删除
  items.pop("name1")  # 根据key删除
  print(items)

---

基本统计方法

• 通过用户输入一组数据(用户一个一个输入),然后计算数据的中位数/平均值/方差/求和

  nums = []
  
  while True:
      num1 = input('请输入你需要输入的数字(输入 q 退出):')
      if num1 == 'q':
          break
      nums.append(int(num1))
  
  # 求中位数
  def get_median(nums):
      nums.sort()  # 排序
  
      nums_len = len(nums)  # 求长度
      if nums_len % 2 == 0:  # 列表内容是偶数
          return (nums[int(nums_len / 2 - 1)] + nums[int(nums_len / 2)]) / 2
      else:  # 列表内容是奇数
          return nums[nums_len // 2]
  
  # 定义求和函数
  def get_sum(nums):  # ['123', '123', '213', '234', '98234']
      count = 0
      for i in nums:
          count += int(i)
  
      return count
  
  # 定义求平均值函数
  def get_average(nums):
      count = get_sum(nums)   # 调用求和函数得到结果
      average_count = count / len(nums)   # 根据求和结果得到平均值
      return average_count
  
  # 定义求方差的函数
  def get_variance(nums):
      average_count = get_average(nums)   # 根据平均值函数得到平均值
      variance_count = 0
      for i in nums:  # 循环列表元素
          variance_count += pow(i - average_count, 2) # 将每一个数据减去平均值后平方并求和
      return variance_count
  
  
  count = get_median(nums)
  print("中位数：",count)
  
  count = get_sum(nums)
  print('求和:',count)
  
  average_count = get_average(nums)
  print('平均值:',average_count)
  
  variance_count = get_variance(nums)
  print('方差:',variance_count)

---

作业

# 字符串练习作业
# name = " aleX"
# 1)    移除 name 变量对应的值两边的空格,并输出处理结果
# 2)    判断 name 变量对应的值是否以 "al" 开头,并输出结果
# 3)    判断 name 变量对应的值是否以 "X" 结尾,并输出结果
# 4)    将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
# 5)    将 name 变量对应的值根据 “l” 分割,并输出结果。
# 6)    将 name 变量对应的值变大写,并输出结果
# 7)    将 name 变量对应的值变小写,并输出结果
# 8)    请输出 name 变量对应的值的第 2 个字符?
# 9)    请输出 name 变量对应的值的前 3 个字符?
# 10)    请输出 name 变量对应的值的后 2 个字符?
# 11)    请输出 name 变量对应的值中 “e” 所在索引位置?
# 12)    获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。

name = " aleX"
# 题目1
res = name.strip(" ")   #  去掉左侧或右侧出现的字符
print(res)

# 题目2
res = name.startswith("al") # 匹配开头字符
print(res)  # 输出 False

# 题目3
res = name.endswith("X") # 匹配结尾字符
print(res)  # 输出 True

# 题目4
res = name.replace("l","p") # 字符串替换
print(res)  # 输出 apeX

# 题目5
res = name.split("l")   # 字符串分割
print(res)  # 输出 [' a', 'eX']

# 题目6
res = name.upper()   # 字符串转大写
print(res)  # 输出  ALEX

# 题目7
res = name.lower()   # 字符串转小写
print(res)  # 输出  alex

# 题目8
res = name[1] # 字符串索引
print(res)  # 输出  a

# 题目9
res = name[:3] # 字符串索引
print(res)  # 输出   al

# 题目10
res = name[-2:] # 字符串索引
print(res)  # 输出   al

# 题目11
for i in range(len(name)):  # 获取长度 输出位序
    if name[i]=="e":
        print(i)
        break

# 题目12
res = name[:-1]   #  去掉左侧或右侧出现的字符
print(res)

# 集合，列表，元组，字典 作业
# 1.将以下数据存储为字典类型
# 数据：info = "name:Owen|age:18|gender:男"
# 结果：{'name': 'Owen', 'age': 18, 'gender': '男'}

# 2.完成数据的去重
# 数据：t3 = [1, 2, 1, 2, 3, 5, 9]
# 结果：t3 = [1, 2, 3, 5, 9]

# 3 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]
# 将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中
# 即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}

# 4.完成录入电话本(选做)

# 题目1：
info = "name:Owen|age:18|gender:男"
info = info.split("|")  # 分割后类型就变为list
items = dict()  # 声明字典
for i in range(len(info)):
    list = str(info[i]).split(":")  # 再次分割
    items.setdefault(str(list[0]),str(list[1]))     # 添加list数据到字典中
print(items)

# 题目2：
t3 = [1, 2, 1, 2, 3, 5, 9]
t3 = set(t3)
print(t3)

# 题目3：
t = {11,22,33,44,55,66,77,88,99,90}
t = list(t)
list1,list2=list(),list()
for i in t:
    if i > 66:
        list1.append(i)
    else:
        list2.append(i)
items = {"k1":list1,"k2":list2}
print(items)

# 题目4：
items,itemsList = dict(),dict()  # 定义字典

while 1:
    name = input("请输入姓名，必须由英文字母组成：")
    if name.isalpha():  # 英文
        if name == "q":
            break
        tel = input("请输入电话，必须由数字组成：")
        if tel.isdigit() and len(tel)==11:  # 必须是数字且长度必须是11位
            key = name[0].upper()           # 取name的首字母并大写，建立分组名

            if itemsList.get(key) != None:      # 如果该分组存在
                items = itemsList.get(key)      # 取字典中value的字典给items
                if items.get(name) != None:     # 如果姓名相同，则保留最新一次电话
                    items.pop(name)
                    items.setdefault(name, tel)
                items.setdefault(name, tel)     # 如果名字不相同，则添加数据到items中
            else:
                itemsList.setdefault(key,{name:tel}) # 不存在则添加
            print(itemsList)
    else:      # 不是英文字母
        print("不是英文字母")
        continue
print(itemsList)
# 难点：
# 当该分组存在时，必须先取出字典中value值中保存的字典。
# 根据该字典判断，value中的值是否和输入的name一致
# 如果一致必须更新value为最新的tel
# 如果不一致直接添加一对数据到取出的字典中。
# 相当于更新了字典中value保存的字典
# 例： {'X': {'xc': '12345678910', 'xh': '12345678910'}, 'C': {'cyx': '12345678910'}, 'L': {'lc': '12345678910'}}

转载于:https://www.cnblogs.com/XuChengNotes/p/11210320.html