python---数据容器
目录
环境安装
python语法
打印语句
注释
变量
变量声明
变量类型
boolean类型
占位符
控制数据精度
输入输出
条件控制
循环语句
while循环
for循环
函数
None类型
数据容器
列表
元组
字符串
序列
集合
字典
环境安装
1、安装python运行环境
Welcome to Python.org
2、安装python的集成开发环境 pyCharm
python语法
打印语句
注释
"""
多行注释
"""
# 单行注释
# 打印字符串内容
print("hello world")
变量
变量声明
变量是存储在内存中的值，这就意味着在创建变量时会在内存中开辟一个空间。
基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。
因此，变量可以指定不同的数据类型，变量可以存储整数，小数或字符。
在java或者c语言，定义一个变量都是需要类型的，比如
int a=0；char ch='a'
但是，Python 中的变量赋值不需要赋予数据类型。
a=10 #将整形数据10赋值给变量啊
print("a= ",a)
a="hello" #将字符串赋值给变量a
print("a= ",a)
a=b=c=9 #也可以连续赋值
print("a= ",a," b= ",b," c= ",c)
一个变量，可以被赋值给不同类型的数据
变量类型
整形和浮点数
在java中，整数数据是int和long类型，小数包括float（四字节，单精度浮点数）和double（八字节，双精度浮点数）
python包括complex（复数）类型，Python 只有一种小数类型，就是 float（这里float扩展为了8字节，等同于double）
long 类型只存在于 Python2.X 版本中，在 2.2 以后的版本中，int 类型数据溢出后会自动转为long类型。在 Python3.X 版本中 long 类型被移除，使用 int 替代。
使用type（）函数可以检测数据类型
a=10 #int类型数据
print(type(a))
a=2147483647+10 #这里 2147483647是int的最大值 int会自动转化为long类型
print("a=",a);
print(type(a));
a=12.3 #Python 只有一种小数类型，就是 float
print(type(a))
#复数
a=complex(1,1);
print("a=",a);
print(type(a))
字符串类型
a='1'
print("a=",a)
print(type(a))
a="123"
print("a=",a)
print(type(a))python是没有char类型的，一个字符也是字符串类型
字符串也可以使用+拼接
boolean类型
和c语言一样，0表示假，非0表示真。只不过一般用1表示真
但是python的True和False，首字母大写
占位符
message="%s,%d,%f" %("张三",123,23.9)
# %s 将张三填入 %d将123填入 %f，将9以小数格式填入
print(message)
控制数据精度
使用m.n可以设置数据精度（m设置宽度，n控制小点数的精度）
小数中，小数点和小数部分也会在m中充当长度，小数数据截断会四舍五入
print("%5d" %12) #设置12这个整数长度为5位,数据长度不足左补空格 [空格][空格][空格]12
print("%1d" %12) #设置12这个整数长度为1位,数据长度大 限制丢失
print("%7.2f" %12.276) #设置数据长度为7位，保留两位小数 [空格][空格]12.28
- ---指定左对齐输出。
0---指定空位填零。
输入输出
使用input（）语句，从键盘获取数据 ；获取到的数据类型都是str
ch=input()
print(ch)
print(type(ch))
条件控制
if 条件语句 ：
执行语句
elif 条件语句：
执行语句
else 条件语句：
执行语句
使用缩进表示以上的层次关系 同一个缩进是对应的判断体系
#猜数字游戏
num=random.randint(0,100)
print(num)
while(True):
print("请输入0~100的整数")
guess=(int)(input()) #这里 应该对输入判断 应该全是数字，且不是小数 为了方便，没有展示
if(guess>num):
print("猜大了")
elif(guess循环语句
while循环
str="hello world"
i=0
while ifor循环
str="hello world"
#str字符串 每次查找到一个字符 结果就赋值给变量 x
for x in str:
print(x)range（）语句
range（x，y，z）语句，生成一定范围内的数字集合[x,y)，左闭右开区间，x默认为0，z是步长，默认为1
a=range(0,10) # 0 1 2 3 4 5 6 7 8 9
for x in a:
print(x)
a=range(6,10) # 6 7 8 9
for x in a:
print(x)
a=range(2,10,2) # [2.10) 内数据 步长为2 结果：2 4 6 8
for x in a:
print(x)变量作用域
for x in range(0,4):
print(x)
print(x) #没有遵守规范,但是可以执行最外层这行代码，在规范来说都是不合法的。因为x是在for循环内部定义的，作用域也应该在for循环内部，其生命周期在for循环结束也结束了。但是python中并没有遵守这一个准则，这一行代码可以正常执行。
不过为了符合编程规范，最好还是不要使用此特殊情况。
| 控制语句 | 描述 |
|---|---|
| break 语句 | 在语句块执行过程中终止循环，并且跳出整个循环 |
| continue 语句 | 在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。 |
函数
使用函数，可以实现某一逻辑的功能
# 定义 sum函数 计算x+y
def add(x,y):
z=x+y
return z
#return 表示这个函数 将值返回
z=add(2,4) #函数调用 并接收返回结果
print(z)
None类型
None是一个特殊的字面常量，表示空的，没有意义
在我们定义的函数没有返回值时，看似没有结果返回，实际上是返回了一个None
# 定义 sum函数 计算x+y
def add(x,y):
z=x+y
print(z)
ret=add(2,3)
print("ret=",{ret})
print(type(ret))
变量在函数中的作用域
- 变量分为局部变量与全局变量
- 由某对象或某个函数所创建的变量通常都是局部变量，只能被内部引用，而无法被其它对象或函数引用。
- 全局变量既可以是某对象函数创建，也可以是在本程序任何地方创建。全局变量是可以被本程序所有对象或函数引用。
- global关键字的作用是可以使得一个局部变量为全局变量。
global关键字可以声明 某一个变量是全局变量。函数内部声明z变量是全局变量，函数内部的z和函数外部的z就成为了同一个变量。
数据容器
数据容器可以存储大量数据。包括：列表，元组，字典，字符串，集合五类
列表
列表的数据项不需要具有相同的类型，有序，可修改
#定义一个列表 并且赋值
a=["123",23]
print(a)
#定义空列表
b=[]
print(b)
c=list()
print(c)
1、列表索引
列表索引 从左向右 下标为0，1，2……，从右向左是-1，-2，-3……
print("正向输出")
list=["汪汪","糖豆","WiFi","章鱼","大鹅"]
#从左向右 下标为 0 1 2 3 4 正向输出每一个元素
i=0
while(i
2、 列表嵌套
#列表嵌套
list=[[1,2,3],["张三",10,11],0,-9]
print(list[0]) #得到的是0下标的元素 也即是一整个列表 [1,2,3]
print(list[1][0]) #得到第二个列表中 第一个元素 ”张三“3、内置函数
python包含一些内置函数，实现了某些功能
#定义一个列表 并且赋值
a=["123","hi","张三"]
#1、求列表元素长度 len()
print(len(a))
####!!!! 注意,一旦涉及到了元素大小的比较,一定是同一类型的元素才可以比较
#2、列表最大值
print(max(a))
#3、列表最小值
print(min(a))
4、列表方法
如果将函数放在某一个类中，就称它为方法，可以通过类对象.方法名调用
| 序号 | 方法 |
|---|---|
| 1 | list.append(obj) 在列表末尾添加新的对象 |
| 2 | list.count(obj) 统计某个元素在列表中出现的次数 |
| 3 | list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| 4 | list.index(obj) 从列表中找出某个值第一个匹配项的索引位置 元素不存在,报错 |
| 5 | list.insert(index, obj) 将对象插入列表 |
| 6 | list.pop([index=-1]) 根据下标删除 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| 7 | list.remove(obj) 根据元素删除 移除列表中某个值的第一个匹配项 元素不存在,报错 |
| 8 | del 列表[index] 根据下标删除 删除某一下标的元素 不返回该元素的值 |
| 9 | list.reverse() 反转列表中元素 |
| 10 | list.sort(cmp=None, key=None, reverse=False) 默认升序，降序让 reverse=True ，key表示指定排序规则的函数 |
#定义一个列表 并且赋值
a=["hi","张三","123"]
#1、获取某一个元素 第一次出现的下标 如果此元素不存在 会报错
print( a.index("123")) #结果2
#2、添加元素 在列表末尾添加元素
a.append("123")
print(a) #结果 hi","张三","123","123"
#3、在列表末尾 添加一个列表
a.extend(["新的列表","元素2"])
print(a) #结果 ['hi', '张三', '123', '123', '新的列表', '元素2']
#4、在指定下标处添加元素或者列表
a.insert(2,"插入元素")
print(a) #结果 ['hi', '张三', '插入元素', '123', '123', '新的列表', '元素2']
a.insert(2,["插入元组1","插入元组2"])
print(a) #结果 ['hi', '张三', ['插入元组1', '插入元组2'], '插入元素', '123', '123', '新的列表', '元素2']
#5、删除元素 根据下标删除
del a [0] #删除下标为0的元素
del a[-1] #删除下标为-1的元素
print(a) #结果 ['张三', ['插入元组1', '插入元组2'], '插入元素', '123', '123', '新的列表']
a.pop() #删除某一个下标的元素 默认下标为-1 也就是删除最后一个元素
print(a) #结果 ['张三', ['插入元组1', '插入元组2'], '插入元素', '123', '123']
#6、删除出现的元素 只删除第一次出现的
a.remove("123") #删除第一个出现的123
print(a) #结果 ['张三', ['插入元组1', '插入元组2'], '插入元素', '123']
#7、统计元素出现的次数
print(a.count("123"))
#8、反转列表元素
a.reverse() #不会返回新的列表 直接修改此列表
print(a)
#9、列表元素排序
#这时 列表元素包含 嵌套的列表和字符串,无法比较大小 我们删除内部列表
a.pop(2)
print(a)
# 对 ['123', '插入元素', '张三']这个列表排序
a.sort()
print(a) #升序排序
a.sort(reverse=True)
print(a) #降序排序
元组
元组在列表的基础上，要求不可修改 支持下标索引
1、定义元组
元组使用小括号，列表使用方括号。
#定义元组
a=(1,2,3) #定义元组 并赋值
b=() #定义空元组
c=tuple() #定义空元组元组中只包含一个元素时，需要在元素后面添加逗号
2、内置函数
#内置函数
print(max(tup))
print(min(tup))
print(len(tup))
3、方法
| 方法 | 说明 |
| tuple.index(obj) | 得到obj这个元素第一次出现的下标 元素不存在报错 |
| del（tuple） | 删除元组类型变量 |
| tuple.count(obj) | 得到obj这个元素的出现次数 元素不存在就是0 |
tup=(1,2,3)
#1、得到某一个元素第一次出现的下标 元素不存在报错
print(tup.index(2))
#2、不可以对元组内容修改 但是可以删除元组(不是删除元组内容,而是直接删除这个变量)
del(tup)
# print(tup) 报错 元素不存在
字符串
字符串也是一种数据容器，因为是字符的集合
字符串也是不可以进行修改的
Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
str="hello"
#1、使用加号 可以进行字符串拼接
print(str+" world")
#2、使用*可以输出多次
print(str*3) #输出三次hello常用方法
| 方法 | 描述 |
|---|---|
| string.count(str, beg=0, end=len(string)) |
返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
| string.find(str, beg=0, end=len(string)) |
检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是，返回开始的索引值，否则返回-1 |
| string.rfind(str, beg=0,end=len(string) ) |
返回字符串最后一次出现的位置，如果没有匹配项则返回 -1。 |
| string.replace(str,obj) | 将字符串的所有str元素，替换为obj元素，返回新的字符串 |
| string.index(str, beg=0, end=len(string)) |
跟find()方法一样，只不过如果str不在 string中会报一个异常. |
| string.upper() |
转换 string 中的小写字母为大写 |
| string.lower() |
转换 string 中所有大写字符为小写. |
| string.replace(str1, str2, num=string.count(str1)) | 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次. |
| string.strip(obj) | 去除首尾obj，没有传入参数时，默认去除字符串前后空格。这里会将obj元素划分为子串，只要是首位字符包括于obj字符串，就会被删除 |
获取到某一下标的元素
print(str[1])
#2、获取元素第一次出现的下标
print(str.find("l"))
#得到元素最后一次出现的下标值
print(str.rfind("l"))
#3、获取到字符串长度
print(len(str))
#4、元素替换
print(str.replace("l","N"))
#5、元素根据空格进行分割 得到一个列表
print(str.split(" "))
#6、去除前后空格
ret=str.strip()
print(ret)
print(ret.strip("12")) #将12看作子串 会删除掉首尾的1和2 结果 Hello World
#7、统计某一个元素的出现次数
print("打印空格出现的次数",{str.count(" ")})序列
序列：内容连续、有序、可以按照索引查找的数据容器
列表，元组，字符串都是序列
序列可以支持切片操作，就是从序列中截取某一部分元素，得到一个新的序列
左闭右开区间
序列[起始下标：结束下标：步长]
- 起始下标：表示从何处开始，默认从0开始
- 结束下标：表示从何处结束，默认数组长度结束
- 步长：表示取元素的间隔 步长为1，表示拿到范围内的所有元素，步长为2，表示跳过一个元素取，例如[2,6]中,步长为2，取出2 4 6
- 步长为负数表示倒着取数据
tuple=(0,1,2,3,4,5,6,7)
#1、从0开始 到长度结束 步长为1 也就是拿到所有数据
tmp=tuple[::1]
print(tmp)
#2、从0开始 到长度结束 步长为2 也就是拿到所有偶数数据
tmp=tuple[::2]
print(tmp)
#3、拿到3 4 5 6数据 左闭右开区间 元素下标取[3,7)，也就是3 4 5 6
tmp=tuple[3:7:1]
print(tmp)
#4、逆序输出
tmp=tuple[::-1]
print(tmp)
#5、逆序输出 步长为2
tmp=tuple[::-2]
print(tmp)
#6、逆序输出5 4 3
#分析:步长-1 开始下标5 结束下标3 因为是开区间,结束位置值是2
tmp=tuple[5:2:-1]
print(tmp)
集合
集合元素不可以重复，且内部无序
集合会去重并且内部无序
因为集合内部无序（存储顺序和输入顺序并不符合）所以不支持下标访问（也就不能使用while循环遍历集合）
| 方法 | 说明 |
| set.add(obj) | 给集合添加一个元素（元素可以是字符串，整体添加字符串）（不添加重复元素） |
| set.update(obj) | 给集合添加元素，如果obj是字符串，会添加obj的每一个字符（不添加重复元素） |
| set.remove(obj) | 从集合删除obj元素，如果元素不存在报错 |
| set.discard(obj) | 从集合删除obj元素，如果元素不存在不会报错 |
| set.pop() | 随机从集合删除一个元素，并且返回这个元素值 |
| set.difference(set1) | 得到两个集合的差集 |
| set.union(set1) | 得到两个集合的并集 |
| set.intersection(set1) | 得到两个集合的交集 |
set={1,2,3,"张三","123","hello"}
print(set)
#1、给集合添加元素 添加字符串,整体添加
set.add("world")
print(set)
#2、删除某一个元素
set.remove("world")
print(set)
set.discard("123")
print(set)
#3、随机从集合删除一个元素
print("随机删除的元素",{set.pop()})
print(set)
#4、将元素添加到集合 添加字符串
set.update("hi")
print(set)
#5、得到两个集合的差集
set1={1,2,3,"张三"}
set2={2,3,0,"李四"}
print("差集：",set1.difference(set2)) #得到set1集合中 set2集合没有的元素
#6、取两个集合的并集
print("并集：",set1.union(set2)) #两个集合的并集
# 7、取两个集合的交集
print("交集：",set1.intersection(set2))
#8、修改集合1的内容 为两个集合的差集
set1.difference_update(set2)
print(set1)
#9、修改集合1的内容 为两个集合的交集
set1={1,2,3,"张三"}
set2={2,3,0,"李四"}
set1.intersection_update(set2)
print(set1)
字典
以键值对的形式存储的数据 根据key访问value
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，对应的value会是最后一次的赋值
2）键必须不可变，可以用数字，字符串或元组充当，用列表就不行
1、定义字典
字典的每个键值 key:value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
a =dict() #定义空字典
print(type(a))
dic={"name":"汪汪","password":123}
print(dic)
#定义嵌套字典
dic1={
"1" :{
"name":"张三",
"password":123
},
"2": {
"name": "王五",
"password": 1232
}
}
2、元素获取、添加、修改、删除
dic={"name":"汪汪","password":123}
#1、根据key 访问value 如果key不存在 报错
print(dic["name"]) #得到 汪汪
print(dic["password"]) # 得到 123
#2、value更新
dic["name"]="two 倩"
print(dic)
#3、添加一个键值对
dic["score"]=90
print(dic)
#4、删除键值对
del dic["score"] #删除指定键值对
print(dic)
dic.clear() #清空所有键值对
print(dic)
del dic #删除dic遍历
#print(dic) #元素不存在3、常用方法
| 方法 | 说明 |
| dict.get(key, default=None) | 返回指定键的值，如果值不在字典中返回default值 |
| dict.keys() | 以列表返回一个字典所有的键 |
| dict.items() | 将键值对信息包装为元组，多个元组包装为一个列表，返回列表 |
| dict.update(dict2) | 把字典dict2的键/值对更新到dict里 key已经存在就覆盖value，不存在就添加 |
| pop(key[,default]) |
删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 key值不存在，报错 |
dic={
"1" :{
"name":"张三",
"password":123
},
"2": {
"name": "王五",
"password": 1232
}
}
#1、获取某一元素
print(dic["1"]["name"]) #张三
print(dic.get("1"))#{'name': '张三', 'password': 123}
print(dic.get("3"))#None
#2、得到所有的key
keys=dic.keys()
for x in keys:
print(dic[x])
#3、得到键值对信息
print(dic.items()) # dict_items([('1', {'name': '张三', 'password': 123}), ('2', {'name': '王五', 'password': 1232})])
items=dic.items()
for x in items: # 得到的 x 形如 ('1', {'name': '张三', 'password': 123})
print(x[0]) #1
print(x[1]["name"]) #张三
print(x[1]["password"]) #123
#4、更新 将dic1的键值对添加入dic 如果key重复,value覆盖,不重复 直接添加
dic1={
"1" :{
"name":"张无忌",
"password":123
},
"3": {
"name": "王五",
"password": 1232
}
}
dic.update(dic1)
print(dic) #{'1': {'name': '张无忌', 'password': 123}, '2': {'name': '王五', 'password': 1232}, '3': {'name': '王五', 'password': 1232}}
#5、删除 根据key删除一个键值对 key不存在 报错
print(dic.pop("3"))
print(dic)