[Python知识库]python基础 序列类型

?

List列表

概念

列表是序列类型的一种扩展，十分常用 ?列表是一种序列类型，创建后可以随意被修改

创建

?使用方括号 [] 或list() 创建，元素间用逗号 , 分隔
?列表中各元素类型可以不同，无长度限制

list01 = [1,2,3,4,5]

#创建空列表
list02=[]
list03=list()

print(list01)
#[1, 2, 3, 4, 5]
print(list02)
#[]
print(list03)
#[]

list04=list(["张三","李四"])
list05=[1,3,4,5,3.14e2,"字符串"]
print(list04)
#['张三', '李四']
print(list05)
#[1, 3, 4, 5, 314.0, '字符串']

常用函数

list01 = [1,2,3,4]

#len(列表) 统计列表中元素的个数
a=len(list01)
print(a)#4

#sum(列表) 求和
b = sum(list01)
print(b) #10

#max(列表) 最大值
c= max(list01)
print(c) #4

#min(列表) 最小值
d = min(list01)
print(d) #1

增加数据

list01 = [1，2，3，2，5]

#list.insert(index,值)  根据下标进行插入数据
list01.insert(1,"8")
print(list01)  #[1,8,2,3,2,5]

#list.append(值) 在末尾插入
list01.append("追加")
print(list01) # [1,8,2,3,2,5,"追加"]

删除数据

list01 = [1，2，3，4，5，3]

#list.pop(index) 删除指定位置的数据
list01.pop(3)
print(list01)  #[1，2，3，5，3]

#list.remove(值) 删除值，但是他删除的是值第一次出现的位置
list01.remove("赵丽颖")
print(list01) #[1，2，5，3]
#list.clear() 删除所有数据
list01.clear()
print(list01) #[]

更改数据

List[i] = 值（要修改的值）

#重新进行赋值
list01=[1,2,3,4]
list01[3] = "杨幂"
print(list01)  #[1,2,3,"杨幂"]

查

#创建list
list01 = [1,2,5,7,-2,-9]

#查询所有 ---直接打印列表名字
print(list01)
"""
  查询单个值
   利用[index]进行查询 index-->从0开始
"""
print(list01[1])  #2
"""
 查询多个值
   [start:stop]   左开右闭
   小数在前面
   正向递增  反向递减   一负一正

   
   -6 -5 -4 -3  -2  -1
   [1  2  5  7  -2  -9]
    0  1  2  3   4   5
"""
print(list01[1:4])  #[2, 5, 7]
print(list01[-5:-2]) #[2, 5, 7]
print(list01[-5:4]) #[2, 5, 7]

常用方法

#list.reverse()   反转
list01 = [1,2,3,4,5,6]
list01.reverse()
print(list01)  #[6, 5, 4, 3, 2, 1]

#list.copy() 拷贝
list02 = list01.copy()
print(list02)

"""
 list.sort(reverse = Ture/False) 排序 默认是升序
 reverse = Ture降序  reverse = False 升序
"""
list03 = [1,8,4,2,-9]
list03.sort()
print(list03) #[-9, 1, 2, 4, 8]
list03.sort(reverse=True)
print(list03)  #[8, 4, 2, 1, -9]

tuple元组

概念

元组是序列类型的一种扩展
元组是一种序列类型，一旦创建就不能被修改 不能增删改

创建

使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔

tuple01 = (1,2,3)
tuple02 = tuple((5,6,7))

#创建空元组  ()
tuple03 = tuple() 

print(tuple01)
print(tuple02)
print(tuple03)

all()

? 空列表 空元组 空集合 空字典都是False

print(all([[],()])) #False

查

#创建

tuple02 = (1,2,3,4,5,6)
"""
 查询所有值  直接打印元组名字
 查询单个值  [index]
 查询多个值  [start:stop] 左开右闭 一负一正 
 -6  -5  -4  -3  -2  -1
 (1,  2,  3,  4,  5,  6)
  0    1   2  3   4   5
 """
print(tuple02)#(1, 2, 3, 4, 5, 6)
print(tuple02[2])#3
print(tuple02[1:4])
print(tuple02[-5:-2])
print(tuple02[-5:4])
'''
(2, 3, 4)
(2, 3, 4)
(2, 3, 4)
'''

运算符

dict字典

概念

1.字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含：“键对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。
2.列表中我们通过“下标数字”找到对应的对象。字典中通过“键对象”找到对应的“值对象”。
3.“键”是任意的不可变数据，比如：整数、浮点数、字符串、元组。但是：列表、 字典、集合这些可变对象，不能作为“键”。并且“键”不可重复。
4.“值”可以是任意的数据，并且可重复。

创建

?键值对：键是数据索引的扩展 ?字典是键值对的集合，键值对之间无序(没有索引）
?采用大括号{}和dict()创建，键值对用冒号: 表示
?字典类型是“映射”的体现
?<字典变量> = {<键1>:<值1>, … , <键n>:<值n>}

dict01 = {"张三":18,"李四":20,"王五":80}
dict03 = dict({"张三":90,"李四":20})

#创建空元组
dict02 = dict()

print(dict01)  #{'张三': 18, '李四': 20, '王': 80}
print(dict03)  #{'张三': 90, '李四': 20}
print(dict02) #{}

增加数据

语法： dict01[新的key] = 新的值 添加数据

dict01 = {"张三":18,"李四":20,"王五":80}
dict01["陈理想"]=20
print(dict01) 
#{'张三': 18, '李四': 20, '王五': 80, '陈理想': 20}

删除数据

dict.pop(key) 根据key删除一对数据
dict.clear() 清除所有数据

dict01 ={'张三': 18, '李四': 20, '王五': 80, '陈理想': 20}
dict01.pop("张三")
print(dict01) 
#{'李四': 20, '王五': 80, '陈理想': 20}

更改数据

只能修改值，不可以修改key 为什么？
因为key是唯一的，不能重复的，避免出现重复的情况所以不能修改
怎么修改：
先根据key拿到值 dict01[20]
再重新赋值

dict01 = {"张三":18,"李四":20,"王五":80}
dict01["陈理想"]=18
print(dict01) 
#{'张三': 18, '李四': 20, '王五': 80, '陈理想': 18}

查讯数据

dict.values() 查询所有的value
dict.keys() 查看所有的key

dict01={'张三': 18, '李四': 20, '王五': 80, '陈理想': 18}
dict.keys()
print(dict01.keys()) 
dict.values()
print(dict01.values())

查询单个值
1.dict[key] 利用key查询value
2.dict.get(key,默认值) 利用key查询value 如果key没有，那么就输出默认值

print(dict01["陈理想"]) #18
print(dict01.get("陈理想"))  #18
print(dict01.get("卡卡","没有这个人")) #"没有这个人"

查询所有值(包括key和value)
1.直接打印字典名
2.dict.items() 迭代方法

print(dict01) #{'张三': 18, '李四': 20, '王五': 80, '陈理想': 18}
print(dict01.items())
 #dict_items([('张三', 18), ('李四', 20), ('王五', 80), ('陈理想', 18)])

常用的函数和方法

k in dict 判断key在不在字典里面
如果在输出True 如果不在输出False
只能判断key在不在，不能判断value在不在

dict01={'张三': 18, '李四': 20, '王五': 80, '陈理想': 18}
print("张三" in dict01) #False
print(20 in dict01) #Ture

#更新
dict01.update(dict02)
把02中的数据更新到01中 更新是更新多个数据
不是复制 但是你可以理解成添加数据

#创建字典
dict01 = {"张三":20,"王五":30,"赵六":70,"李四":80}
dict02 = {"翠花":20,"光头强":10}
dict01.update(dict02)
print(dict01) #{'张三': 20, '王五': 30, '赵六': 70, '李四': 80, '翠花': 20, '光头强': 10}
print(dict02) #{'翠花': 20, '光头强': 10}

#创建字典
dict01 = {"张三":20,"王五":30,"赵六":70,"李四":80}
dict02 = {"翠花":20,"光头强":10}

"""
  del 字典名[key]  删除指定位置的数据
  和pop一样 
  dict.pop(key) 删除指定位置的数据
"""
del dict01["李四"]
print(dict01) #{'张三': 20, '王五': 30, '赵六': 70}

字符串

概念

字符串：由0个或多个字符组成的有序字符序列
字符串由一对单引号或一对双引号表示
字符串是字符的有序序列，可以对其中的字符进行索引

“hello”---->h e l l o
索引 0 1 2 3 4

基本操作

b = "李同学"
c = "李同学张同学刘同学"
#b是c的子集
print(b in c)#True

字符串的序号

正向递增反向递减

使用[ ]获取字符串中一个或多个字符 数值小的在前面 [1:5] [-6 :-1]
之间有区间的时候，可以使用一负一正
索引：返回字符串中单个字符 <字符串>[M]
切片：返回字符串中一段字符子串 <字符串>[M: N]
左开右闭 print(a[8:14]) print(a[8:15])
虽然索引没有15，但同样我们也取不到15的这个数据

"""
  正向递增   0  1  2  3  4  5  6
  反向递减  -7 -6 -5  -4 -3 -2 -1    
           笔  记 真  多 太  难 了
"""
Str = "笔记真多太难了"
print(Str[2:4])
print(Str[-5:-3])
print(Str[-5:4])
'''
真多
真多
真多
'''

转义字符

1.转义符形成一些组合，表达一些不可打印的含义

2.可以去掉特殊含义

#让这个双引号去掉本身含义，就打印双引号
print("我想\"吃饭\"")#我想"吃饭"

常用函数

len() 获取字符串的长度

a = len("今天天气不错")
print(a)

str() 把任意数据类型转换成string

b = 30
print(type(b))
c = str(b)
print(type(c))
#Type()输出数据类型的

#hex() 十进制转换成十六进制(0x)
print(hex(99))
#oct() 十进制转换成八进制(0o)
print(oct(99))

#chr() 十进制转换成字符
print(chr(68))
#ord() 字符转换成十进制
print(ord('A'))

方法

方法本身也是函数
方法是一个特殊的函数

str.lower() 把字符串转换成小写 返回字符串

a = "ABC"
print(a.lower())#abc

str.upper() 把字符串转换成大写 返回字符串

b = "like"
print(b.upper())#LIKE

str.split()

#str.split(按照什么拆分)  拆分 返回的是list列表[]
c = "I,love,you"
print(c.split(","))
#['I', 'love', 'you']

str.count()

#str.count(子串)  某一个子串在str(字符串)中出现的次数  返回值整数类型
d = "o"
#o在I,love,you中出现了多少次  2 
print(c.count(d))#2
print(type(c.count(d)))

str.replace()

#str.replace(old,new)  str中的任意一个子串替换成新的子串  返回字符串
Str01 = "I,LOVE,YOU"
Str02 = Str01.replace("YOU", "李雪琴")
print(Str02)

str.center()

#str.center(宽度,新的字符)  Str字符串根据某一个宽度进行居中 返回值字符串
"""
宽度 = 新的字符+str
新的字符必须是一个字符
"""
Str03 = "陈欣雨"
Str04 = Str03.center(10)
print(Str04)
Str05 = Str03.center(10,"")
print(Str05)

str.strip

#str.strip(字符) 去掉左右两边的字符 返回字符串
Str06 = "==I,LIVE,YOU=="
Str07 = Str06.strip("=L")
print(Str07)

格式化

第一种方式

?使用百分号进行格式化输出的方式，用法如下：

%s 表示字符串；
%d 表示整数；
%f 表示浮点数。
% 代表一个占位符

name = "张三"
age = 18
print("%s is %d year old"%(name,age))

1.字符串和int不能拼接
2.对数据有未知性

格式化：能让数据更加明了

sp="口红"
jg= 399
print("%s名字为%s的%s是%d"%("商品",sp,"价格",jg))
#商品名字为口红的价格是399
#占位符必须和参数一一对应，否则，语句不通顺，报错

第二种方式

?，用法如下：

<模板字符串>.format(<逗号分隔的参数>)

"""
<模板字符串> .format(<逗号分隔的参数>)
第一种
  利用{}为占位符
"""
print("{}是{}".format"我","谁"))
#我是谁

"""
第二种
  利用索引（索引从0开始）
"""
print("{1}是{0}".format("谁","张三")
#谁是张三

"""
 第三种
  利用变量的赋值
"""
print("{c}是{a}".format(c="他",a="张三")
#他是张三

大括号{}内部对格式化的配置方式

参数序号：默认是0
填充字符：默认空格

# 对齐方式：默认是左对齐
> 
>>> "{0:=^20}".format("python","hello")
'=======python======='
>>> "0:*>20".format("bit")
'0:*>20'
>>> "{0:*>20}".format("bit")
'*****************bit'
>>> "{:10}".format("bit")
'bit       '
>>> "{:,.2f}".format(123456.78901)
'123,456.79'
>>> "{:x}".format(99)
'63'
>>> "{1}的温度是{0:.1f}C".format(31.97,"今天")
'今天的温度是32.0C'

set集合

概念

集合是多个元素的无序(没有下标)组合
集合类型与数学中的集合概念一致
集合元素之间无序，每个元素唯一，不存在相同元素
集合元素不可更改，不能是可变数据类型

数据重复，会自动去重

创建

?集合用大括号 {} 表示，元素间用逗号分隔
?建立集合类型用 {} 或 set()
?建立空集合类型，必须使用set()

#创建
set01 = {1,2,3,4,5}
#创建空集合
set02 = set() 
set03 = set({9,10,11})
print(set01)#{1, 2, 3, 4, 5}
print(set02) #set()
print(set03)#{9,10,11}

创建空集合的时候必须使用set()
原因是空字典的创建也是{}，两者冲突了

print(type({})) #<class 'dict'>
print(type(set())) #<class 'set'>

增加数据

#创建
set01 = {1,2,3,4}

"""
set.add(数据) 添加一个数据  也能添加已有的数据，
虽然不报错，但是不显示
"""
print(set01) #{1,2,3,4}
set01.add(5)
print(set01) #{1,2,3,4,5}

"""
 set01.update(set02) 批量添加数据
   把set02添加到zet01中
"""
set02 = {7,9}
set01.update(set02)
print(set01)#{1, 2, 3, 4, 5, 7, 9}

删除数据

set01 = {2,3,4,5,6}

"""
  set.discard(值)  删除集合中的值 
    如果数据不存在，不报错
""" 
set01.discard(2)
print(set01) #{3,4,5,6}
set01.discard(1)
print(set01)

"""
 set.remove(值) 删除集合中的值 
   KeyError: 值
   如果没有这个值，会报错
"""
set01.remove(6)
print(set01) #{3,4,5}
#set01.remove(0)
#print(set01)

"""
 set.pop() 随机删除
"""
set01.pop() 
print(set01)

set.clear() 清空数据

更改数据

set集合不可以更改数据
集合元素不可更改，不能是可变数据类型
因为无序唯一

查询数据

直接打印集合名字去查询 不能使用索引进行查询
因为我们集合是无序的
set01={9,9,9,9}
print(set01)#{9,9,9,9}

集合常用函数和方法

set01 = {"喜羊羊","美羊羊","懒洋洋","沸羊羊","暖羊羊","慢羊羊","灰太狼"}

#set.copy() 复制/拷贝一个一模一样的集合
set02 = set01.copy()
print(set02) #{'慢羊羊', '美羊羊', '灰太狼', '喜羊羊', '沸羊羊', '暖羊羊', '懒洋洋'}

#len(set) 返回集合的元素个数，集合的长度
a = len(set01)
print(a) #7

"""
 x in set 元素x在不在集合当中
 x not in set 元素不在集合中
"""
print("慢羊羊" in set01) #True
print("慢羊羊" not in set01) #False

#set(x) 把其他数据类型（x）转换成集合类型 
Str = "hello"
print(Str) #hello
print(type(Str))

b = set(Str)
print(type(b)) #<class 'set'>
print(b) #{'o', 'e', 'h', 'l'}

逻辑运算符

并

 """
 并
   1.他的符号是  |
   2.返回两个集合的所有值
"""
set01={1,2,3,4,5}
set02={2,3,5,7,9}
print(set01 | set02) #{1,2,3,4,5,7,9}

差

"""
 差
   1.差的符号是  -
   2.set01 - set02  set01去掉公共部分的值
"""
print(set01 - set02) #{1, 4}
print(set02 - set01) #{9, 7}

交

"""
 交
   1.交的符号  &
   2.两个的公共部分
"""
print(set01 & set02)  #{2, 3, 5}

补

"""
 补集
  1.补集的符号 ^
  2.并集-交集 = 补集
  3.除去公共部分，set01和set02的单独部分我都要
"""
print(set01 ^ set02) #{1, 4, 7, 9}

包含关系

判断set01 和 set02是不是包含关系

< >= <=
口朝向那边，那边是大的
set01 >= set02 set01包含set02

set01={1,2,3,4,5}
set02={2,3,5}
print(set01 >= set02) 
print(set01 < set02) 
print(set02 < set01) 
#True
#False
#True

增强符

s |= t — s=s | t

"""
  set01 |= set02  并等   set01 = set01 | set02

"""
set01={1,2,3,4,5}
set02={2,3,5}
s = set01 | set02
print(s)#{1, 2, 3, 4, 5}

set01 |= set02
print(set01) #{1, 2, 3, 4, 5}