Python基础（2）

变量的数据类型

1.数字类型
整数 int
浮点数 float
布尔 bool (布尔类型参与计算时, True为1, False为0)
2.非数字类型
字符串 str
列表 list
元组 tuple
字典 dict

查看变量的数据类型

type()函数(也是Python中自带的函数)
1.作用: 可以查看变量或数据的类型
2.方式: type(变量名) 或 type(数据)

Python中变量的数据类型是自动类型推导:
1.变量名 = 变量值, 是根据 等号右边数据类型 自动 推导出 变量名中的数据类型

容器：

容器：也可以称为数据序列，或者高级数据类型，也是python中的数据类型
容器中可以存放多个数据。

字符串的定义格式

1.作用: 字符串主要用来处理文本数据的

2.定义格式:

(1)成对的双引号  或  成对的单引号
    my_str =  "xxx"         my_str =  'yyy'
(2)成对的三个双引号  或  成对的三个单引号 
    my_str = """xxxx"""        my_str = '''uuu'''
(3)定义字符串的特殊形式(原生字符串) (正则表达式)(了解)
     my_str = r"I\"m good man"  

字符串中的数据不允许修改, 需要通过方法修改(拷贝)
字符串和数字之间不能比大小，但可以判断是否相等（一定不相等）

3.说明: 字符串是一个有序的容器,有序的容器可以通过索引访问

索引: 数据在字符串中位置下标,默认从0开始
注意: 通过索引获取数据不要越界

4.字符串的查询(下标)

(1)通过索引（下标）获取数据
语法：字符串名[索引值] / 字符串名[下标]
作用：获取指定位置的字符
数据在字符串中位置下标,默认从0开始（在python中支持负数下标，从右到左进行编号，从-1开始）
(2)通过数据获取索引
字符串名.index(小字符串)

5.统计字符串

(1)统计字符串的长度
len(字符串名)
(2)统计大字符串中某个小字符串出现的次数
字符串名.count(小字符串)

6.切片

切片：会得到一个字符串，即可以获取字符串中的多个字符（多个字符的下标是有规律的，等差数列）
语法：
字符串[start：end：step]
start是开始位置的下标，end是结束位置的下标（注意，不能取到这个位置的字符）step步长，等差数列的差值，所取的相邻字符下标之间的差值，默认是1，可以不写

7.判断

string.startswith(str) 检查字符串是否是以 str 开头， 是则返回 True
string.endswith(str) 检查字符串是否是以 str 结束， 是则返回 True

8.查找 find

 用法：
string.find(str, start =0,end =len(string))
# start 和 end 指定范围， 则检查是否包含
# 在指定范围内， 如果在字符串中找到了str,返回str第一次出现的正数下标， 否则返回 -1（空格也是一个字符）
# 没有找到返回-1   
# 下边的代码正常执行

# string.index(str, start=0,end=len(string)) 跟 find() ⽅法类似，
# 不过如果 str 不在 string 会报错
# 没有找打会报错, 下边的代码不执行

9.替换 replace

字符串的替换  重点
string.replace(old_str, new_str , num=string.count(old))
old_str：被替换的内容
new_str ：替换为的内容
count：替换的次数，一般不写，默认是全部替换
返回：替换之后的完整的字符串
注意：原来的字符串没有发生改变
把 string 中的 old_str 替换成 new_str，
如果 num 指定， 则替换不超过 num次

10.字符串的拆分 与 拼接

字符串的拆分 split
字符串. split（sep,maxsplit） # 将字符串按照 sep 进行分割（拆分）

**拆分**

① string.split(str="",num) 以 str 为分隔符拆分 string， 如果 num 有指定值， 则仅分隔 num + 1 个⼦字符串，
   str 默认包含 '\r', '\t', '\n' 和空格, 返回列表  
② string.splitlines() 按照⾏('\r', '\n', '\r\n')分隔，返回⼀个包含各⾏作为元素的列表

字符串的链接 join
（列表）——列表中的内容必须为字符串

拼接

① 常用的字符串拼接
  string.join(seq) 以 string 作为分隔符， 将 seq 中所有的元素（的字符串表示） 合并为一个新的字符串
② 字符串加法拼接 +

源字符串中数据并没有改变, 把源字符串做了拷贝, 对拷贝后的数据进行修改

列表

1、作用： 是用来存放多个数据的高级容器, 有序的高级容器
2、说明：列表中可以存储多个数据，可以存放任意类型数据，每个数据之间用逗号隔开
3、定义：列表名 = [数据1, 数据2 , 数据3 …]
空列表： 列表名 = list() 、 list []
4、访问列表中数据:
通过索引访问：列表名[索引值]
注意：索引不要越界

添加:

列表.append（数据）

# 列表.insert(索引, 数据) 在指定位置插入数据
# 列表.append(数据) 在末尾追加数据
# 列表1.extend(列表2) 将列表2 的数据追加到列表1( 把列表2 合并到列表1中去)

删除:

在列表中删除中间的数据，那么后面的数据汇向前移动
1、根据下标删除

 语法：列表.pop(下标) 	# 删除指定下标位置对应的数据  有返回值
（1）下标不写，默认删除最后一个数据（常用）
（2）书写存在的下标，删除对应下标位置的数据

 返回：返回的是删除的数据

2、根据数据值删除

语法：列表.remove(数据)	# 根据数据值删除，

返回：None
注意：如果要删除的数据不存在，会报错
如果列表中有多个相同的数据，只能删除第一个

3、清空数据（一般不用）

语法：列表.clear() 	# 清空列表

# del 列表[索引] 删除指定索引的数据
# 列表.remove(数据) 删除第一个出现的指定数据  常用
# 列表.pop() 删除末尾数据 (返回删除的数据)
# 列表.pop(索引) 删除指定索引数据  有返回值
# 列表.clear() 清空列表

修改:

列表[下标] = 数据	# 字符串中字符不能使用下标修改

# 列表[索引] = 数据  修改指定索引的数据

查询 index :

列表名.index(数据)
列表名.count(数据)

# 通过索引获取数据
  列表名[索引]
# 通过数据获取索引
  列表名.index(数据)   获取数据在列表中第一次出现的索引值（下标）

和 find（）查询方法的区别：index（）方法，找到—返回第一次出现的下标，没有找到—代码直接报错

高级操作:

判断容器中某个数据是否存在：

判断容器中某个数据是否存在可以使用 in 关键字
数据 in 容器 # 如果存在返回 Ture，如果存在，返回 False

列表切片

# 列表的切片
list1 = ['小米',18,1.65,True]

# 获取第一个数据，名字
print(list1[0])

# 获取最后一个数据
print(list1[-1])

# 获取第一、二个数据
print(list1[0:2])

# 列表支持 len(列表)求列表长度，求列表中元素的个数
print(len(list1))

统计 :

# len(列表) 列表长度 (列表中元素的个数)  

# 列表.count(数据)   返回数据在列表中出现的次数   

列表的排序 :

一般来说都是对数字进行排序的
升序
语法：列表.sort（） # 按照升序排序，从小到大
降序
语法：列表.sort（reverse = Ture） # 降序排序，从大到小

# 列表.sort() 升序排序 (从小到大排序) 
# 列表.sort(reverse=True) 降序排序 (从大到小进行排序)
# 列表.reverse() 逆序、 反转  反转: 前面的数据放到后面, 后面的数据放到前面   

列表反转（倒置）

语法：字符串中 反转倒置：字符串[：：-1]
列表中 反转和倒置
1、列表[：：-1] #使用切片的方法，会得到一个新列表，原列表不会发生改变
2、列表.reverse（） #直接修改列表，返回None

# 列表反转（倒置）
my_list = [1, 3, 5, 7, 9 , 2, 4, 6, 8, 0]
# 使用切片的方法，会得到一个新列表，原列表不会发生改变
list2 = my_list[::-1]
print('my_list:', my_list)  # my_list: [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
print(' list2 :', list2)    # list2 : [0, 8, 6, 4, 2, 9, 7, 5, 3, 1]

# 使用 reverse 方法，直接修改列表，返回None
my_list.reverse()
print('my_list:', my_list)  # my_list: [0, 8, 6, 4, 2, 9, 7, 5, 3, 1]

列表复制 :

将列表中的数据复制一份，给到一个新的列表 # 使用场景：有一个列表，需要修改操作列表中的数据，修改之后，需要和原数据今对比，即原数据不能改
1、使用切片
变量 = 列表[ ：]
2、使用 copy方法
变量 = 列表名.copy( )

列表嵌套

使用下标来确定获取的是什么类型的数据
列表可以多层嵌套
不论多少层都可以使用下标进行访问

person_info  = [["张三", "18", "功能测试"],["李四", "20", "自动化测试"]]
print(len(person_info))    # 2
print(person_info[0])   # ['张三', '18', '功能测试']
print(person_info[0][0])    # 张三
print(person_info[0][0][0])     # 张

person_info[0][1] = 19  # ['张三', '19', '功能测试']
# 添加
person_info[1].append('男')  # ["李四","20","自动化测试",'男']
# 删除
person_info[0].pop(1)
# person_info[0].remove('18')
print(person_info)  # [['张三', '功能测试'], ['李四', '20', '自动化测试', '男'

id()函数可以查看变量保存数据的内存地址

注意：列表支持下标和切片， 使用方法和字符串中的使用方法一致
区别：列表的切片得到的是列表

添加数据的方法:

尾部添加（最常用）

列表.append(数据)	# 将数据整体[]添加到列表的尾部
返回：返回的None (关键字，空),一般就不再使用 变量 来保存返回的内容，想要查看添加后的列表，需要打印的是原列表

指定下标位置添加

列表.insert(下标，数据)	# 在指定下标位置添加数据，如果指定下标位置本来有数据，原数据就会后移
返回：返回的None (关键字，空),一般就不再使用 变量 来保存返回的内容，想要查看添加后的列表，需要打印的是原列表

列表合并

列表1.extend(列表2)	# 将列表2的数据逐个添加到列表1的尾部
返回：返回的None (关键字，空),一般就不再使用 变量 来保存返回的内容，想要查看添加后的列表，需要打印的是原列表

元组tuple

1.类似于列表 用来存储数据的容器( 可以存储,int float, bool, str, 元组本身, 列表(list))，可以存放任意多个数据

注意: 元组中的数据不允许修改(除非数据是列表和字典)
应用：在函数的传参或者返回值中使用，保证数据不会被修改

2.定义
（1）使用类实例化方式
（2）直接使用（ ）
元组: 元组名 = (数据1,数据2,数据3,…)
元组名 = () 或 tuple()
包含一个元素的元组 元组名 = (数据,)

3.访问元组的数据
通过索引(下标)访问元组中数据
方式: 元组名[索引值]

4.注意: 访问元组时, 要防止元组越界错误 IndexError: tuple index out of range

5.注意: 元组中的数据不允许修改(除非是列表和字典)

6.元组常见的操作:

① 通过索引获取数据 元组名[索引值]
② 通过数据获取索引 元组名.index(数据) # 数据不存在报错
③ 统计 count() 统计元组中某个数据出现的次数 元组名.count(数据)
④ 获取元组长度 len(元组名)
也可以使用 in 操作，来判断数据是否存在

字典dict

字典中的数据是由键（key）值（value）对去组成的（键表示数据的名字，值就是具体的数据）
在字典中一组键值对是一个数据，多个键值对之间使用 逗号隔开
变量= {key ：value，key：value，…}

# 字典: 也是用来存储数据的一种高级容器( 像问卷调查表)
# 作用: 字典一般用来描述人物或事物的详细信息
# 以键值对的方式来存储数据
# 问卷调查表:   ---> 字典
# 姓名:    张三
# 年龄:    20
# 身高:    178.5
# 住址:    北京市海淀区
# 电话:    10086
# key(键): value(值)
# 字典是以键值对的方式来存储数据的
# 键和值之间使用 : 隔开
# 键值对与 键值对之间使用 , 隔开

1.字典是用来存储的数据的一种容器(一般用来存储事物详细信息的容器)
2.字典是通过键值对的方式来存储数据的
3.语法格式: 字典名 = {key1:value1, key2:value2, key3:value3 …}
空字典: 字典名 = {} 或 dict()
4.字典的类型 dict
4.1.字典中的键key 是唯一的，不能重复的，值可以是任意数据
5.字典的键 和 值 的数据格式
字典的键(key) 只能是除了 列表 和 字典以外的任意数据类型 ，一般都是字符串，可以是数字
字典的value值可以是任意数据 类型
6.字典中的数据是无序,列表中数据有序
7.访问字典的数据
通过key获取值
格式: 字典名[key]
8.字典不能转列表、元组和字符串

8.字典的常见操作:

增加和修改

语法：
字典[键] = 数据值
1、如果键已经存在，就是修改数据值
2、如果键不存在，就是添加数据（即键值对）

# 定义字典 小明 18 爱好
my_dict = {"name": "小明", "age": 18, "like": ['唱歌', '看书', '画画']}  # {'name': '小明', 'age': 18, 'like': ['看书', '写字', '画画']}
print(my_dict)
# 1.添加性别信息
my_dict["sex"] = "男"
print(my_dict)  # {'name': '小明', 'age': 18, 'like': ['唱歌', '看书', '画画'], 'sex': '男'}
# 2.修改年龄为28
my_dict["age"] = 28
print(my_dict)  # {'name': '小明', 'age': 28, 'like': ['唱歌', '看书', '画画'], 'sex': '男'}

# 3.添加一个爱好，学习—— 本质是项列表添加一个数据
my_dict["like"].append("学习")
print(my_dict)  # {'name': '小明', 'age': 28, 'like': ['唱歌', '看书', '画画', '学习'], 'sex': '男'}

① 字典名[key] = value,
key存在,修改数据,
key不存在, 新建键值对
② 字典名.setdefault(key, value)
key存在,不修改数据,(使用默认值),
key不存在, 新建键值对
③ 字典1名.update(字典2) # 把字典2合并到字典1中去,
字典1中 key存在,更新数据,
字典1中 key不存在, 新建键值对

删

• 删除指定键值对

  del 字典[键]
  字典.pop( ' 键 ' )  #键必须写
  

• 清空

  字典.clear
  

# 删除 sex 键值对
del my_dict["sex"]
print(my_dict)  # {'name': '小明', 'age': 28, 'like': ['唱歌', '看书', '画画', '学习']}

# 字典.pop( ' 键 ' )
my_dict.pop('age')
print(my_dict)  # {'name': '小明', 'like': ['唱歌', '看书', '画画', '学习']}

# 删除一个键值对——本质是在列表中删除数据值
# my_dict["like"].pop(0)
my_dict["like"].remove("唱歌")
print(my_dict)  # {'name': '小明', 'like': ['看书', '画画', '学习']}

# 清空键值对
my_dict.clear()
print(my_dict)  # {}

① del 字典名[key]
key存在, 删除 key对应的键值对
key不存在,报错
② 字典名.pop(key)
key存在, 删除 key对应的键值对
key不存在,报错
③ 字典名.popitem() 随机删除键值对
④ 字典名.clear() 把字典内容清空(字典结构依然存在)

查

字典中没有下标的概念，想要获取数据值，要使用key(键)来获取

• 使用字典[键]

  字典[键]
  1.如果键存在，返回键对应的数据值
  2.如果键不存在，会报错
  

• 使用字典.get（键）

  字典.get(键，data)
  1.数据值一般不写，默认是None
  
  返回：
  1.如果键存在，返回键对应的数据值
  2.如果键不存在，返回的是 括号中书写的数据值
  

一般建议使用 get 方法

① 字典名[key]
key存在 正常取值,
key不存在,报错 (报错后面的代码不再执行)
② 字典名.get(key)
key存在 正常取值,
key不存在,不会报错, 返回 None (报错后面的代码可以继续执行)

字典的高级应用

1.len(字典名) 获取的字典中键值对的个数
2.高级用法 了解
① 字典名.keys() 获取所有的键(key) 组成的特殊的列表
② 字典名.values() 获取所有的值(value) 组成的特殊的列表
③ 字典名.items() 获取所有的键(key)和值(value) 组成元组, 元组组成的特殊的列表

作用: 主要用来遍历列表,元组,字典,字符串这样的序列容器
遍历就是一个一个的从容器中获取数据
语法:
for 临时变量 in 容器:
对临时变量的处理
说明: for可以遍历 列表,元组,字典,字符串这样的序列容器
不能遍历数字, 浮点数,布尔类型