字符串

数据序列 , 容器 字符串 str, 列表 list,元组 tuple, 字典 dict
了解 集合 set
使用引号(单引号, 双引号, 三引号)引起来的内容,就是字符串

数据序列 , 容器 字符串 str, 列表 list,元组 tuple, 字典 dict
了解 集合 set
使用引号(单引号, 双引号, 三引号)引起来的内容,就是字符串

1. 使用单引号
str1 = 'hello'
2. 使用双引号定义
str2 = "hello"
3. 使用 三引号 定义
str3 = """hello"""
str4 = '''hello'''
print(type(str1), type(str2), type(str3), type(str4))

4. 定义字符串 I’m 小明, 字符串本身包含引号

4.1 如果字符串本身包含单引号,定义的时候不能使用 单引号,

4.2 如果字符串本身包含双引号,定义的时候不能使用 双引号,

str5 = “I’m 小明”
print(str5) # I’m 小明

5. 转义字符 \n \t ’ "

str6 = 'I\'m 小明'
print(str6) # I'm 小明
6. I\'m 小明 \\ --> \
str7 = 'I\\\'m 小明'
print(str7) # I\'m 小明7. 原生字符串 在字符串的前边 加上 r"", 字符串中的 \ 就不会进行转义str8 = r'I\'m 小明'
print(str8) # I\'m 小明str7 = r'I\\\'m 小明'
print(str7) # I\\\'m 小明

下标(索引)

1, 下标(索引), 是数据在容器(字符串, 列表, 元组)中的位置, 编号
2, 一般来说,使用的是正数下标, 从 0 开始
3, 作用: 可以通过下标来获取具体位置的数据. 使用的语法为容器[下标]
4, Python 中是支持负数下标, -1 表示最后一个位置的数据

str1 = ‘abcdefg’

需求: 打印输出字符串中的 a 字符

print(str1[0])
print(str1[-7])

需求: 打印输出字符串中 最后一个字符(-1)

print(str1[-1])

需求: 打印输出 下标为 3 的位置的字符

print(str1[3])

切片

1, 使用切片操作, 可以一次性获取容器中的多个数据(多个数据之间存在一定的规律,数据的下标是 等差数列(相邻的两个数字之间的差值是一样的))
2, 语法 容器[start🔚step]
2.1 start 表示开始位置的下标
2.2 end 表示结束位置的下标,但是 end 所对应的下标位置的数据是不能取到的
2.3 step 步长,表示的意思就是相邻两个坐标的差值
start, start+step, start+step*2, …,end(取不到)

my_str = 'abcdefg'
# 需求1 : 打印字符串中 abc 字符 start 0, end 3, step 1
print(my_str[0:3:1])  # abc
# 1.1 如果步长是 1, 可以省略不写
print(my_str[0:3])  # abc
# 1.2 如果 start 开始位置的下标为 0, 可以不写,但是冒号不能少
print(my_str[:3])  # abc
# 需求 2: 打印字符串中的 efg , start 4, end 7, step 1
print(my_str[4: 7])  # efg
# 2.1 如果取到最后一个字符, end  可以不写,但是冒号不能少
print(my_str[4:])  # efg
# 需求 3: 打印字符串中的 aceg , start 0, end 7(最后), 步长 2
print(my_str[::2])  # aceg

字符串查找方法 find()

字符串.find(sub_str) # 在字符串中 查找是否存在 sub_str 这样的字符串
返回值(这行代码执行的结果):
1, 如果存在sub_str, 返回 第一次出现 sub_str 位置的下标
2, 如果不存在sub_str, 返回 -1

# 1. 现有字符串数据: '黑马程序员'
# 2. 请设计程序, 实现判断"黑马"和"白马"是否存在于数据中
# 3. 要求如果数据存在, 则输出数据所在位置
my_str = '黑马程序员'
# sub_str = '黑马'
sub_str = '白马'
result = my_str.find(sub_str)
if result == -1:print(f'{sub_str}不存在')
else:print(f'{sub_str}存在, 下标位置为:', result)

字符串的替换 replace()

字符串.replace(old, new, count) # 将字符串中的 old 字符串 替换为 new 字符串

• old 原字符串,被替换的字符串
• new 新字符串,要替换为的字符串
• count 一般不写,表示全部替换, 可以指定替换的次数
• 返回: 会返回一个替换后的完整的字符串
• 注意: 原字符串不会改变的

my_str = 'good good study'
# 需求, 将 good 变为 GOOD
my_str1 = my_str.replace('good', 'GOOD')
print('my_str :', my_str)
print('my_str1:', my_str1)
# 将第一个 good 替换为 Good
my_str2 = my_str.replace('good', 'Good', 1)
print('my_str2:', my_str2)
# 将第二个 good  替换为 Good
# 先整体替换为 Good, 再将替换后的 第一个Good 替换为 good
my_str3 = my_str.replace('good', 'Good').replace('Good', 'good', 1)
print('my_str3:', my_str3)

字符串拆分 split()

字符串.split(sep) # 将字符串按照指定的字符串 sep 进行分隔

• sep , 按照 sep 分隔, 可以不写, 默认按照空白字符(空格 \t \n)分隔
• 返回: 列表,列表中的每个数据就是分隔后的字符串

str1 = 'hello Python\tand itcast and\nitheima'
# 1. 默认 按照空白字符分隔
list1 = str1.split()
print(list1)  # ['hello', 'Python', 'and', 'itcast', 'and', 'itheima']
# 2. 按照 空格分隔
list2 = str1.split(' ')
print(list2)  # ['hello', 'Python\tand', 'itcast', 'and\nitheima']
# 3. 按照 and  分隔
list3 = str1.split('and')
print(list3)  # ['hello Python\t', ' itcast ', '\nitheima']

字符串的连接 join

字符串.join(容器) # 容器一般是列表 , 将字符串插入到列表相邻的两个数据之间,组成新的字符串
注意点: 列表中的数据 必须都是字符串才可以

list1 = ['hello', 'Python', 'and', 'itcast', 'and', 'itheima']
# 将 列表中数据使用 空格 组成新的字符串
str1 = ' '.join(list1)
print(str1)  # hello Python and itcast and itheima
# 使用 逗号 连接
str2 = ','.join(list1)
print(str2)  # hello,Python,and,itcast,and,itheima
# 使用 _*_ 连接
str3 = '_*_'.join(list1)
print(str3)  # hello_*_Python_*_and_*_itcast_*_and_*_itheima

列表 list

1, 列表,list, 使用 []
2, 列表可以存放任意多个数据
3, 列表中可以存放任意类型的数据
4, 列表中数据之间 使用 逗号隔开

# 方式1, 使用类实例化的方式
# 1.1 定义空列表  变量 = list()
list1 = list()
print(type(list1), list1)  # <class 'list'> []
# 1.2 定义非空列表 , 也称为 类型转换  list(可迭代类型)  可迭代类型,能够使用 for 循环 就是 可迭代类型(比如 容器)
# 将容器中的 每个数据 都作为列表中一个数据进行保存
list2 = list('abcd')
print(list2)  # ['a', 'b', 'c', 'd']
# 方式2, 直接使用 [] 进行定义(使用较多)
# 2.1 定义空列表
list3 = []
print(list3)
# 2.2 定义非空列表
list4 = [1, 3.14, 'hello', False]
print(list4)
# 获取 列表中 第一个数据
print(list4[0])  # 1
# 获取列表中最后一个数据
print(list4[-1])  # False
# 获取中间两个数据即 3.14 和 'hello' (1 和 2)
print(list4[1: 3])  # [3.14, 'hello']

列表的增删改查

查

list1 = ['hello', 2, 3, 2, 3, 4]
# 查找 2 出现的下标
num = list1.index(2)
print(num)
# 统计数据 2 出现的次数
num1 = list1.count(2)
print(num1)
# 统计数据 20 出现的次数
num2 = list1.count(20)
print(num2)  # 0

增和删

# 定义空列表
list1 = []
print(list1)
# 添加数据 张三
list1.append('张三')
print(list1)
# 添加李四
list1.append('李四')
print(list1)
list1.append('王五')
list1.append('赵六')
print(list1)
# 删除最后一个数据
list1.pop()
print(list1)
# 删除第二个数据
name = list1.pop(1)
print('删除的对象为:', name)
print(list1)

修改数据

列表的排序

想要修改列表中的数据, 直接是所有下标即可 列表[下标] = 新数据

my_list = [1, 2]
my_list[0] = 10
print(my_list)
my_list[-1] = 200
print(my_list)

列表的反转 reverse()

字符串 反转 字符串[::-1]

列表 反转

1. 列表[::-1] 得到一个新的列表, 原列表不会改动
2. 列表.reverse() 直接修改原列表的数据

my_list = ['a', 'b', 'c', 'd', 'e']
# 1. 切片
my_list1 = my_list[::-1]
print('my_list :', my_list)
print('my_list1:', my_list1)
# 2. reverse
my_list.reverse()
print('my_list :', my_list)

排序

列表.sort() # 升序, 从小到大, 直接在原列表中进行排序
列表.sort(reverse=True) # 降序, 从大到下, 直接在原列表中进行排序

my_list = [1, 4, 7, 2, 5, 8, 3, 6, 9]
# 排序 升序
my_list.sort()
print(my_list)
# 降序
my_list.sort(reverse=True)
print(my_list)

列表嵌套

student_list = [["张三", "18", "功能测试"], ["李四", "20", "自动化测试"], ["王五", "21", "自动化测试"]]
# 张三
print(student_list[0][0])
# 李四
print(student_list[1][0])
# 张三 的信息添加一个 性别 男 ---> 向张三所在的列表 添加数据
student_list[0].append('男')
print(student_list)
# 删除 性别
student_list[0].pop()
print(student_list)
# 打印 所有人员的年龄
for info in student_list:  # info 是 列表print(info[1])

元组 tuple

my_list = [1, 4, 7, 2, 5, 8, 3, 6, 9]

排序 升序

my_list.sort()
print(my_list)

降序

my_list.sort(reverse=True)
print(my_list)
列表的嵌套 就是指 列表中数据都是列表.
student_list = [[“张三”, “18”, “功能测试”], [“李四”, “20”, “自动化测试”], [“王五”, “21”, “自动化测
试”]]

# 张三
print(student_list[0][0])
# 李四
print(student_list[1][0])
# 张三 的信息添加一个 性别 男 ---> 向张三所在的列表 添加数据
student_list[0].append('男')
print(student_list)
# 删除 性别
student_list[0].pop()
print(student_list)
# 打印 所有人员的年龄
for info in student_list: # info 是 列表print(info[1])

1, 元组 tuple, 使用的 ()
2, 元组和列表非常相似, 都可以存储多个数据, 都可以存储任意类型的数据
3, 区别就是 元组中的数据不能修改,列表中可以修改
4, 因为元组中的数据不能修改,所以只能 查询方法, 如 index, count ,支持下标和切片
5, 元组, 主要用于传参和返回值

交换变量

1, 在定义元组的时候, 小括号可以省略不写
2, 组包(pack), 将多个数据值组成元组的过程 a = 1, 2 # a = (1, 2)
3, 拆包(解包 unpack), 将容器中多个数据 分别给到多个变量, 需要保证容器中元素的个数和变量 的个数保持一致

a, b = b, a
print(a, b)
x, y, z = 'abc'
print(y) # b

字典 dict

1, 字典 dict, 使用 {} 表示
2, 字典是由键(key)值(value)对组成的, key: value
3, 一个键值对是一组数据, 多个键值对之间使用 逗号隔开
4, 在一个字典中, 字典的键 是不能重复的
5, 字典中的键 主要使用 字符串类型, 可以是数字
6, 字典中没有下标

# 1, 类实例化的方式
my_dict1 = dict()
print(type(my_dict1), my_dict1)  # <class 'dict'> {}
# 2, 直接使用 {}  定义
# 2.1 定义空字典
my_dict2 = {}
print(my_dict2)
# 2.2 定义非空字典, 姓名, 年龄, 身高, 性别
my_dict = {"name": "小明", "age": 18, "height": 1.78, "isMen": True}
print(my_dict)
# 将年龄改为 20
my_dict['age'] = 20
print(my_dict)
# 添加 体重 weight
my_dict['weight'] = 65
print(my_dict)
my_dict.pop('weight')
print(my_dict)
my_dict.pop('height')
print(my_dict)

增加和修改

字典[‘键’] = 值

1, 键 存在, 修改

2, 键 不存在, 添加

删除 字典的删除是根据字典的键 删除键值对 字典.pop(‘键’)

查询

方法一: 字典[‘键’] # 键 不存在,会报错

方法 二 字典.get(键) # 键不存在,返回 None

my_dict = {'name': '小明', 'age': 20}
# 获取 name 值
print(my_dict['name'])
print(my_dict.get('name'))
# 获取 性别 sex
# print(my_dict['sex'])   # 会报错, 因为 键不存在
print(my_dict.get('sex'))

遍历

1.遍历字典的键

for 变量 in 字典:
print(变量)

for 变量 in 字典.keys(): # 字典.keys() 可以获取字典所有的键
print(变量)

2.遍历字典的值

for 变量 in 字典.values(): # 字典.values() 可以获取字典中是所有的值
print(变量)

3.遍历字典的键和值

变量1 就是 键, 变量2 就是值

for 变量1, 变量2 in 字典.items(): # 字典.items() 获取的是字典的键值对
print(变量1, 变量2)

my_dict = {'name': '小明', 'age': 18, 'sex': '男'}
for k in my_dict:print(k)
print('*' * 30)
for k in my_dict.keys():print(k)
print('-' * 30)
for v in my_dict.values():print(v)
print('_*_' * 30)
for k, v in my_dict.items():print(k, v)

容器

in 操作符
in 是 Python 中的关键字.
数据 in 容器 可以⽤来判断 容器中是否包含这个数据, 如果包含返回 True,如果不包含返回 False
对于字典来说,判断的是 字典中是否包含这个键

集合

集合 set, {数据, 数据, …}

1, 集合中的数据是不能重复的, 即没有重复数据
2, 应⽤, 对列表进⾏去重操作 就是类型转换 , 可以将 列表转换为 集合, 然后再将集合转换为列表

# 遍历原列表
# for i in my_list:
# # 判断数据是否存在新列表
# if i in new_list:
# # 存在 什么都不操作
# pass
# else:
# # 不存在, 添加到新列表

函数

函数: 将多⾏代码(可以实现⼀个特定的功能)放在⼀块,并给它起⼀个名字. 在需要使⽤多⾏代码的时候, 可以使⽤名字代替.
定义函数的好处: 减少代码冗余(重复的代码不需要多次书写),提⾼编程效率

定义,就是给多⾏代码起名字的过程函数的定义需要使⽤ 关键字 def, 单词 define

定义函数的⼩技巧

1, 先不使⽤函数,将多⾏代码写完
2, 在多⾏代码的上⽅使⽤ def 起名字
3, 使⽤ tab 键, 将多⾏代码进⾏缩进

def login():print('1. 输入用户名')print('2. 输入密码')print('3. 输入验证码')print('4. 点击登录')
login()

参数

参数: 在函数定义的时候,在括号中写⼊变量,这个变量就称为是函数的参数. 形式参数(形参)
在函数调⽤的时候,可以给定义时候的形参传递具体的数据值,供其使⽤. 实际参数(实参)

def sun_2_num(a, b):  # a, b  形参c = a + bprint(c)
sun_2_num(10, 20)   # 10, 20 实参 10 给 a,  20 给 b

函数的嵌套调⽤

def test01():print(1)print('func01')print(2)
# 2. 定义名为test02的函数，打印当前函数的名称，并 调用test01函数
def test02():print('func2')test01()print(4)

函数的返回值

1.在⼀个函数中,想要返回⼀个数据(想要有返回值), 需要使⽤ return 关键字

2.为什么返回值? 在函数中可能通过各种代码,得到的数据结果,想要在函数外部使⽤,就需要使⽤返回值
3, 如果函数有返回值, ⼀般在调⽤的时候 会使⽤变量来接收(保存) 返回值, 以便后续使⽤

4.return 关键字的作⽤, 将⼀个数据值返回到调⽤的地⽅

5.函数遇到 return 会结束函数的执⾏ return 关键字只能⽤在函数中
6, 如果⼀个函数 没有写 return,可以认为 返回值

def get_max(a, b):if a > b:return aelse:return bprint('我会执行吗, 不会执行')

模块导⼊的⽅法

1.import 模块名 # 模块名 就是代码⽂件名 ,不要 .py

2.from 模块名 import 功能名 # 导⼊指定的功 # 可以使⽤快捷键 Alt 回⻋

_name 变量

1, 导⼊模块的时候, 会执⾏模块中的代码
2, 作⽤: 如果在导⼊模块的时候, 模块中的部分代码不想被执⾏, 可以使⽤ name 来解决
3, name 变量,是 Python 解释器内置的变量(变量的值是⾃动维护的), 每个代码⽂件中,都有这个变量
3.1 在模块中 直接右键运⾏代码⽂件, name 变量的值是 ‘main’
3.2 如果是被导⼊运⾏代码⽂件, name 变量的值 是 模块名(⽂件名)

class HouseItem:"""家具类"""def __init__(self, name, area):self.name = name   # 名字self.area = area   # 占地面积def __str__(self):return f"{self.name} 占地面积 {self.area} 平米"
class House:"""房子类"""def __init__(self, h_type, area):self.h_type = h_type    # 户型self.total_area = area  # 总面积self.free_area = area   # 剩余面积和总面积一样self.item_list = []     # 刚开始没有家具def __str__(self):return f"户型:{self.h_type}、总面积:{self.total_area} 平米、剩余面积:{self.free_area}平米、家具名称列表:{self.item_list}"def add_item(self, item):  # 1. 房子对象(self)   2. 家具对象(传参)"""添加家具, item 家具对象"""# 1. 先判断房子的剩余面积和家具的占地面积的关系if self.free_area > item.area:  # 对象.属性  获取属性值print(f'添加家具: {item.name}')self.item_list.append(item.name)# 修改剩余面积self.free_area -= item.areaelse:print(f"房子剩余面积不足,换个大房子吧.....")
if __name__ == '__main__':# 创建家具对象bed = HouseItem('席梦思', 4)chest = HouseItem('衣柜', 2)table = HouseItem('餐桌', 1.5)print(bed)print(chest)print(table)# 创建房子house = House('三室一厅', 100)print(house)house.add_item(bed)print(house)house.add_item(chest)print(house)house.add_item(table)print(house)

可变类型与不可变类型

根据内存中的数据是否允许修改,将数据类型分为可变类型与不可变类型
简单理解: 不使用等号,能不能修改数据值
可变类型: 可以修改

• 列表(list) list.append()
• 字典(dict ) dict.pop()
• 集合(set)
  不可变类型: 不允许修改
• 数字类型(int , float , bool)
• 字符串(str)
• 元组(tuple)

my_tuple = (1, 2, [10, 20])  # 元组中 存储的 1 的地址, 2 的地址, 列表的地址
print(my_tuple, id(my_tuple), id(my_tuple[-1]), id(my_tuple[-1][-1]))
my_tuple[-1][-1] = 30  # 修改的列表中最后一个位置的引用
print(my_tuple, id(my_tuple), id(my_tuple[-1]), id(my_tuple[-1][-1]))

局部变量和全局变量

def func1():    num = 10  # 局部变量    print(num)

函数有多个返回值

def calc(a, b):"""返回两个数的和及差"""return a + b, a - b
result = calc(10, 20)
print(result)

传参方式

def show_info(name, age):print(f"name:{name}, age: {age}")
# 位置传参
show_info('小明', 18)
# 关键字传参
show_info(age=18, name='张三')
# 混合使用
show_info('李四', age=17)

函数定义的时候, 给形参一个默认的数据值,这个参数就是缺省参数(默认参数)
def show_info(name, age=18, sex='保密'):print(name, age, sex)
# 调用
show_info('张三', 18, '男')

多值参数(可变参数/不定长参数)

1.在函数定义的时候,不确定在调用的时候,实参有多少个,此时可以使用 多值参数
2, 在普通的参数前边加上一个 *, 这个参数就变为 多值参数
3, 这个参数可以接收任意多个位置传参的数据, 类型 元组
4, 这个形参一般写作 args(arguments), 即 *args

匿名函数

匿名函数: 使用 lambda 关键字 定义的表达式,称为匿名函数

lambda 参数, 参数: 一行代码 # 只能实现简单的功能,只能写一行代码

匿名函数 一般不直接调用, 作为函数的参数使用的

user_list = [{'name': '张三', 'age': 22, 'title': '测试工程师'},{'name': '李四', 'age': 24, 'title': '开发工程师'},{'name': '王五', 'age': 21, 'title': '测试工程师'}]
# user_list.sort()   # 只能对数字,字符串排序
# 根据字典的 age 键 排序
# 想要对列表中的字典排序,需要 key 形参来指定根据字典中的什么键排序
# key 这个参数需要传递一个函数,使用匿名函数
# 列表.sort(key=lambda x: x['键'])
def func(x):return x['age']
user_list.sort(key=lambda x: x['age'])
# user_list.sort(key=func)
print(user_list)

案例

# 定义一个列表, 保存所有学生信息
# stu_list = []
stu_list = [{'name': 'aa', 'age': '11'}, {'name': 'bb', 'age': '22'}, {'name': 'cc', 'age': '33'}]
def make_student():"""录入单个学生信息"""name = input('请输入姓名:')age = input('请输入年龄:')# 将学生信息存入字典stu_dict = {"name": name, "age": age}# 返回单个学生信息return stu_dict
def show_stu_info():"""展示学生信息"""print('---------学生列表信息-----------')j = 1  # 初始序号for stu_dict in stu_list:  # stu_dict 字典print(f"{j}\t\t{stu_dict.get('name')}\t\t{stu_dict.get('age')}")j += 1  # 修改序号print('-------------------------------')
def get_student_counts():"""获取学生的数量"""return len(stu_list)
def search_student():"""查询学生的信息"""name = input('请输入要查询的学生姓名:')for stu_dict in stu_list:if name == stu_dict.get('name'):# 找到了这个学生print(f'姓名:{name}, 年龄: {stu_dict.get("age")}')# 终止return  # 结束函数的执行# 写在循环的外边print(f'对不起, 名字叫 [{name}]的学生不存在')
if __name__ == '__main__':# 录入三个学生信息# for i in range(3):#     stu = make_student()#     # 需要将单个学生添加到列表#     stu_list.append(stu)## print(stu_list)# 展示学生信息show_stu_info()# 获取学生数量print('学生总数为: ', get_student_counts())search_student()

    print('-------------------------------')
def get_student_counts():"""获取学生的数量"""return len(stu_list)
def search_student():"""查询学生的信息"""name = input('请输入要查询的学生姓名:')for stu_dict in stu_list:if name == stu_dict.get('name'):# 找到了这个学生print(f'姓名:{name}, 年龄: {stu_dict.get("age")}')# 终止return  # 结束函数的执行# 写在循环的外边print(f'对不起, 名字叫 [{name}]的学生不存在')
if __name__ == '__main__':# 录入三个学生信息# for i in range(3):#     stu = make_student()#     # 需要将单个学生添加到列表#     stu_list.append(stu)## print(stu_list)# 展示学生信息show_stu_info()# 获取学生数量print('学生总数为: ', get_student_counts())search_student()