Python 精简笔记 基础 - 集合

Python 笔记 基础(到集合)

1.基础知识

变量类型

科学计数法

e前不为空，e的后面不能为小数

a=e1   #error

a=1e-0.2  #error

a=-1e-1   #True
a=1e-1    #True

a=0.2e-1  #true

变量名

1.变量名必须由字母、下划线、数字组成 ，变量名不能数字开头

输出

输出有四种方式

1.直接print

print("hello bit")

2.格式化print

pirnt("a=%d"%2)

3.format

print("a={:}".format(10))

4.f-string

print(f"hello {bit}")

eval 函数

• eval函数是个非常好用的输入函数

name,age=eval(input())

print(name) # "li"
print(age)     18

# eval会把双引号去掉 如果你需要的是字符串形式输入的时候加双引号

判断语句

• if

• if -elif -else

• if -else

• else可有可无

• 有些题目问if判断执行了多少次，意思是 if 条件： 进行了多少次判断

• 也就是进行了多少次判断真假

循环语句

• while

• while - else

• 只有当while是正常结束才会执行else

• break跳出 不执行else continue 终止 会执行else

break 和 else

• break 跳出当前层循环，继续执行循环体以外的语句
• continue 终止当层循环，继续下次循环

2.字符串

• 不可变类型
• 可以根据索引来输出

下标和切片

• 当遇到负索引，可以转成正索引来分析

如果想取出部分字符，那么可以通过下标的方法，（注意python中下标从 0 开始）

name = 'abcdef'

print(name[0])  # a
print(name[1])  # b
print(name[2])  # c

字符串的操作

查找

• find

• S.find(sub[, start[, end]])

• 返回所查找的内容在字符串中第一次出现的开始位置索引值，如果不存在，返回-1

• rfind 从右边开始查找

s="hello world"
print(s.find("l"))  # 2

print(s.find("x",0,3))  #从0-3的位置找x 找不到 返回-1

• index
• S.index(sub[, start[, end]])
• 与find功能差不多，但index未找到则报错

str1 = 'abcd'
print(st1.index('x'))   #err

字符次数

• conunt

• S.count(sub[, start[, end]])

• 返回所查询字符串 在start和end之间 在 原字符串 里面出现的次数

s="hello world"
print(s.find("l"))  # 3 

print(s.find("z"))  # 0 没出现就为0 

长度

• len(s)

st1='hello'
print(len(st1))   #5

替换

• replace
• replace(old, new, count)
• 不会改变原字符串、给个返回值
• old 旧字符 new 要换的新字符 count 换多少个

st1 = 'hello'
print(st1.replace('l','e'))  #heeeo

print(st1.replace('l','e',1)) #heelo

---

大小写修改

• s.title()

• 每个单词首字母变大写

• s.capitalize()

• 首单词首字母大写

• s.upper()

• 全变大写

• s.lower()

• 全变小写

• s.casefold()

• 所有大写字母转小写

• s.swapcase()

• 大小写互换

---

判断

• startswith

• s.startswith("内容",开始下标,结束下标)

• 判断是否以指定内容开头

• 开始和结束下标可省略

• 如是返回True、反而False

• endswith

• s.endswith("内容",开始下标,结束下标)

• 判断是否以指定内容结尾

• 如是返回True、反而False

isalpha 方法：s.isalpha( )

• 判断字符串是否为纯字母，只有全为字母为True

isdigit 方法：s.isdigit( )

• 判断字符串是否为纯数字

isalnum 方法:s.isalnum( )

• 判断字符串是否数字或字母组成，出现其他都为False

istitle 方法：s.istitle()

• 判断是否字符串每个单词首字母为大写，其他为小写 返回True

isspace 方法：s.isspace( )

• 判断字符串是否为空格字符，当只有空格字符才为True

---

补空格

• s.ljust(num)
• 返回指定长度的字符串，并在右侧使用空白字符补全(左对齐)
• 如果本身字符串 = num 不做处理

a="hello"
print(a.ljust(10))  # hello     在右边补了五个空格

• s.rjust(num)

• 和ljust一样，但从左边补

• s.center(num)

• 在两端使用空白字符补全

---

分割字符串

• split

• s.split(sep=None,maxsplit=-1)

• 将字符串分割成列表 被分割字符会被舍弃

• 默认以空格为分割

• rsplit 从右开始分割

s="hello world s"
print(s.split())   #["hello","world","s"]

print(s.split("l"))  #以l进行分割 #['he', '', 'o wor', 'd s']

• partition

• s.partition("分隔符")

• 将字符串以分隔符分为、分隔符前 、分隔符、分隔符后

• 分割后组成元组

s="helo world"
a=s.partition("l")  # ('he', 'l', 'o world')
					#	前   分割符   后
print(a)

拼接

• join

• 分隔符.join(变量名)

• 作用：把列表或者元组转变成为字符串，并且以分隔符分隔

• 列表和元组内的元素必须是字符串型

• li=['hello','bit']
  s1=' '.join(li)
  print(s1)
  # hello bit
  
  s2='|'.join(li)
  print(s2)
  hello|bit
  

3.列表

• 列表元素可以是不同类型
• 元素可以通过下标获取
• 可以通过下标修改列表的值

# 下标修改
list =[123,"str",22,'a']
list[0]=2
list[1]=50
print(list)
# 2 50 22 a

列表嵌套

• 也叫多维列表

li1 = [1,[1,2],3]  #二维

li2 = [1,2,3,[12, [23,55] ] ] #三维

print(li1[1][1])  # 2
print(li2[3][1][0]) #23

列表创建

• list()

a = list(1,23,4)   #[1,23,4]

• 列表推导式

li1 = [x for x in range(5)] #[0,1,2,3,4]

a = [x for x in range(11) if(x%2==0)]   #生成1-10的偶数列表

增

• append：添加元素到列尾

li=[1,2,3,4]
li.append(5)
# 1,2,3,4,5

• extennd
• 把另一个列列表中元素逐一添加到别的类表

li=[1,2,3]
s=[4,5,6]

li.extend(s)   # [1,2,3,4,5,6]

• insert
• insert（下标，内容）
• 添加指定位置的元素到列表中

li1 = [1,2,3,4]
li.insert(1,33)
print(li1)
#1,33,2,3,4

删

• del
• 删除列表指定元素 或 全部

li = [1,2,3,4]
del li[3]
print(li)  #1,2,3

del li     #全删 不留口列表

• pop

• 删除列表最后一个元素

• remov

• remove(元素)

• 根据元素的值删除

• 如果删除元素不存在则报错

a=[1,222,3,4]
a.remove(222)     #[1,3,4]  当删除元素不存在报错

• clear
• 清空列表 留下空列表

排序

• sort()

• 永久排序

• 默认升序

a=[1,3,2,6]

a.sort()    #1,2,3,6

a.sort(reverse = True)  #降序 6，3，2，1
a.sort(reverse = False) #升序 1，2，3，6

• sorted(变量,排序方式)

• 临时排序，得用变量接收

• 默认升序

  a=[1,2,3,6]
  print(sorted(a,reverse = True)) #6 3 2 1
  

• s.reverse()

• 反序

• 从后往前排序 等价于 [ : :-1]

冒泡排序

#降序
li=[1,5,6,7]
for i in range(len(li)-1):
    for j in range(len(li)-1-i):  
        if(li[j]>li[j+1]):
            li[j],li[j+1]=li[j+1],li[j]

列表函数

• 注意：sum(对象) 全部相加和
• ​ sum(对象,设定值) 全部相加合加上设定值值

4.元组

• 不可变类型
• 值可以重复、可以是不同类型

元组创建

• tuple()

  tup=tuple('abc') #('a','b','c')
  

• 推导式

tup = tuple(x for x in range(1,3))
#必须转换

下标

• 元组可以通过下标访问
• 值不能修改

list(122(13,22,11),"aa",100)

print(list[0])
print(list[1])
lis2=list[0]+list[:-1]  # 222

list=(122,13,"aa",100)

list[0]=21
list[1]=100
print(list)
#TypeError: 'tuple' object does not support item assignment

删

• del s
• 只能删除整个

字符次数

• count(值)

list=(1,2,2,12,2)
print(list.count(2))        # 3

查找

• index()

list=(1,2,2,12,2)
print(list.index(1))        # 0

5.字典

• 1.字典是通过键值对存储
• 键名必须是不可变类型
• 值可以重复、键名不可重复

字典创建

dic = {'age':18,'name':'ghm'}

• s = dict()

s = dict(name= 'lbb',age=18)
#这里的name、age 相当于是用变量当键名
# 所以不能是数字开头

• 推导式

dict={f"age{x}":x  for x in range(1,4)}

print(dict)

键名不重复

# 重复的键名会以最后一个覆盖前面 

访问元素

• 通过键名来访问

• print(dict[键名])

• dict={"name":"lb","age":19,"sex":"man"}
  
  print(dict['name'])   #lb
  print(dict['sex'])    #man
  #注意括号里是字符串格式
  

---

fromkeys

• s.fromkeys(序列，设定值)

• 默认设定值为None

• l1="abcd"
  
  d2={}.fromkeys(l1,'#')  
  #{'a': '#', 'b': '#', 'c': '#', 'd': '#'}
  
  #如果去掉#默认值为None 
  

增

• 当键名不存在 则可以通过下标加入
• 如果键名存在 则改它的值

dic = {'age1':18,'age2':19}

dic['age3'] = 90

{'age1':18,'age2':19,'age3':90}

• s.updata(字典名)
• 将另一个字典逐一添加导另一个字典后

dic={"aa":12,"bb":13,"cc":15}
dic.update({"xx":17,"tt":2})
print(dic)
#{'aa': 12, 'bb': 13, 'cc': 15, 'xx': 17, 'tt': 2}

• s.setdefault(键名、设定值)
• 设定值默认为None
• 当键名不存在返回设定值、并把 键名：设定值 添加到字典中
• 当键名存在 则返回键名对应值

d1 = {"男1":19,"男2":22}
print(d1.setdefault("男2"))
print(d1)
#22
#{'男1': 19, '男2': 22}


d1 = {"男1":19,"男2":22}
print(d1.setdefault("男3"))
print(d1)
#None
#{'男1': 19,'男2': 22,'男3': None}

d1 = {"男1":19,"男2":22}
print(d1.setdefault("男3",45))
print(d1)
#45
#{'男1': 19,'男2': 22,'男3': 45}

删

• del
• 通过键名删除

dict={"age1":18,"age3":21}

del dict["age1"]     #{"age3":21}

• s.pop(键名,设定值)
• 通过键名删除
• 不存在返回设定值，如无设定值报错

dic={"aa":12,"bb":13}
x=dic.pop("aa")          
print(x)                   # 12

dic={"aa":12,"bb":13}
x=dic.pop("cc")          
print(x)                   # 报错

dic={"aa":12,"bb":13}
x=dic.pop("cc",None)          
print(x)                   # None

• s.clear()
• 清空字典

dict={"age1":18,"age3":21}

dict.clear()  #{ }

• popitem
• 删除最后一个键值对返回一个元组 (键名,值)

dic = {"aa":12,"bb":13,"cc":14}
x = dic.popitem()
print(x)
#("cc",14)

遍历

• 1 遍历字典的键 key

• 2 遍历字典的值 value

• 3遍历字典的键值对 items

• dict = {"name":"卢本伟","sex":"M"}
  #遍历字典的key（键）
  for key in dict.keys():
      print(key)
  
  print("---")
  
  #遍历字典的value（值）
  for value in dict.values():
      print(value)
  
  print("---")
  #遍历字典的key-value（键值对）
  for key,value in dict.items():
      print("key=%s,value=%s"%(key,value))
  

6.集合

• 集合无序、元素不可重复
• 重复的值会被最后一个一样的覆盖

集合的创建

• 空集合
• 只能通过 set()创建
• 但有限制 set一次只能建一个字符串并且只能是字符串类型
• 字符串会被拆成单字符

vars=set("aaz1z")

print(vars)  

#{"a","z","l"}

增

• s.add(值)

set1 ={1,3,4}
set.add(5)
# 1 3 4 5

• updata(序列)
• 追加序列(不能是单个值)

xxxxxxxxxx s1 = {10, 20}
s1.update(100) # 报错
s1.update([100, 200])
s1.update('abc')
print(s1)

删

• s.remove(值) 指定删除 值不存在报错

• s.discard(值) 指定删除 值不存在不报错

• s.pop() 随即删除

• del 删除整个集合

• s.clear() 清空集合

集合类型

[

差集：取一个集合中另一个集合没有的元素

对称差集：取集合 A 和 B 中不属于 A&B 的元素

s1={1,2,4}
s2={3,4,5}
print(s1-s2)
#  1 2

print(s1^s2)
# 1 2 3 5

list1=[[1,2],[3,5]]
print(dict(list1))  #{1:2,3:5}

tup1=((1,2),(3,5))
print(dict(tup1))   #{1:2,3:5}

字符串类型

• 字符串会被拆成单字符

vars=set("aaz1z")

print(vars)  

#{"a","z","l"}

增

• s.add(值)

set1 ={1,3,4}
set.add(5)
# 1 3 4 5

• updata(序列)
• 追加序列(不能是单个值)

xxxxxxxxxx s1 = {10, 20}
s1.update(100) # 报错
s1.update([100, 200])
s1.update('abc')
print(s1)

删

• s.remove(值) 指定删除 值不存在报错

• s.discard(值) 指定删除 值不存在不报错

• s.pop() 随即删除

• del 删除整个集合

• s.clear() 清空集合

集合类型

差集：取一个集合中另一个集合没有的元素

对称差集：取集合 A 和 B 中不属于 A&B 的元素

s1={1,2,4}
s2={3,4,5}
print(s1-s2)
#  1 2

print(s1^s2)
# 1 2 3 5

容器转换

1.字符串、元组、集合、字典(只保留key) —> 可转 列表

2.1.字符串、列表、集合、字典(只保留key) —> 可转 元组

3.字符串、列表、元组 、字典(只保留key) —> 可转 集合

4.列表、元组 —> 转 字典(要二级列表/元组且每个二级列表只有两个值)

list1=[[1,2],[3,5]]
print(dict(list1))  #{1:2,3:5}

tup1=((1,2),(3,5))
print(dict(tup1))   #{1:2,3:5}