DAY-03课堂笔记

容器:字符串str，列表list，元组tuple，字典dict
了解 集合set

字符串str

定义

使用引号（单引号，双引号，三引号）引起来的内容

• 代码实现

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

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

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

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

• 代码

  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 小明
  

• 原生字符串

  在字符串的前边 加上 r"", 字符串中的 \ 就不会进行转义
  

  str8 = r'I\'m 小明'
  print(str8)              # I\'m 小明
  str7 = r'I\\\'m 小明'
  print(str7)              # I\\\'m 小明
  

下标（索引）

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

切片

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

# 需求1 : 打印字符串中 abc 字符
my_str = 'abcdefg'  
print(my_str[0:3:1]) # abc
#end取不到，所以一般end+1

# 1.1 如果步长是 1, 可以省略不写
print(my_str[0:3]) # abc
# 1.2 如果 start 开始位置的下标为 0, 可以不写,但是冒号不能少
print(my_str[:3]) # abc

print(my_str[-3:-1:]) #ef
# 特殊情况, 步长为 -1, 反转(逆序) 字符串
print(my_str[::-1]) # gfedcba

len()

num = len(数据)
适用类型: 字符串、列表、元组、字典

str_data = "hello python"
print(len(str_data)) # 12: 字符中字符个数（包含空格）

list_data = ["python", "java"]
print(len(list_data)) # 2: 列表中元素个数

tuple_data = ("admin", 123456, 8888)
print(len(tuple_data)) # 3: 元组中元素个数

dict_data = {"name": "tom", "age": 18, "gender": "男"}
print(len(dict_data)) # 3: 字典中键值对的个数

字符串查找方法 find()

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

data = "黑马程序员"
index = data.find("黑马")
print(f"index={index}")      #index=0
index1 = data.find("程序员")
print(f"index={index1}")     #index=2
index2 = data.find("白马")
print(f"index2={index2}")    #index=-1

字符串的替换 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)                # my_str : good good study
print('my_str1:', my_str1)               # my_str1: GOOD GOOD study
# 将第一个 good 替换为 Good
my_str2 = my_str.replace('good', 'Good', 1) 
print('my_str2:', my_str2)               # my_str2: Good good study
# 将第二个 good 替换为 Good
# 先整体替换为 Good, 再将替换后的 第一个Good 替换为 good
my_str3 = my_str.replace('good', 'Good').replace('Good', 'good', 1)
print('my_str3:', my_str3)               # my_str2: Good good study

字符串拆分 split()

字符串.split(分割符)     按照指定字符来分割字符串
注意：
1. 方法执行完成后返回的数据类型为列表(list)
2. 不传入分割符时，默认以空格(空白字符\t,\n)进行拆分

data = "hello Python and\titcast and itheima"
print(data.split("and"))      # ['hello Python ', ' itcast ', ' itheima']--->按字符
print(data.split())           # ['hello', 'Python', 'and', 'itcast', 'and', 'itheima']--->按空白字符
print(data.split(" "))        # ['hello', 'Python', 'and\titcast', 'and', 'itheima']-->空格拆分，\t就不拆了

字符串的连接 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)

列表 支持下标 和 切片

列表查询方法：

index() --（索引）方法

index() 这个方法的作用和 字符串中的 find() 的作用是一样
列表中是没有 find() 方法的, 只有 index() 方法
字符串中 同时存在 find() 和 index() 方法

两者区别：
1, 找到 返回下标
2, 没有找到, 直接报错

count()方法

列表.count(数据) # 统计 指定数据在列表中出现的次数   返回值int类型

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

列表增加方法：append()【重点】

列表.append(数据) # 向列表的尾部添加数据
# 返回: None, 所以不用使用 变量 = 列表.append()
直接在原列表中添加数据, 不会生成新的列表,如果想要查看添加后的数据, 直接 print() 打印原列表

list1 = ['hello', 2, 3, 2, 3, 4]
print(list1.count(2))
list1.append(2)        # 2
print(list1.count(2))  # 3
print(list1)           # ['hello', 2, 3, 2, 3, 4, 2]

列表删除方法：pop()

列表.pop(index) # 根据下标删除列表中的数据
- index 下标可以不写, 默认删除在最后一个
- 返回, 删除的数据

list1 = ['hello', 2, 3, 2, 3, 4]
print(f"被删除的数据：{list1.pop()}")      # 4
print(list1)                            # ['hello', 2, 3, 2, 3]
print(f"被删除的数据：{list1.pop(0)}")    # hello
print(list1)                           # [2, 3, 2, 3]

列表修改方法：下标/索引

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

列表[下标] = 新数据  #指定的下标不存在，报错（下标越界）

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

列表的反转--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)  # my_list1: ['e', 'd', 'c', 'b', 'a']
# 2. reverse   直接修改原列表的数据
my_list.reverse()
print('my_list :', my_list)   # my_list : ['e', 'd', 'c', 'b', 'a']

列表的排序

# 前提: 列表中的数据要一样
列表.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:
    print(info[1])

元组tuple

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

# 1. 类实例化方式
# 1.1 定义空元组(不用)--->不能修改，增加：没有意义
tuple1 = tuple()
print(type(tuple1), tuple1)    # <class 'tuple'> ()

# 1.2 -类型转换-, 将列表(其他可迭代类型)转换为元组
tuple2 = tuple([1, 2, 3])
print(tuple2)

# 2. 直接使用 () 定义
# 2.1 定义空元组
tuple3 = ()

# 2.2 非空元组
tuple4 = (1, 2, 'hello', 3.14, True)
print(tuple4)
print(tuple4[2]) # hello

# 2.3 定义只有一个数据的元组, 数据后必须有一个逗号
tuple5 = (10,)
print(tuple5)

元组的特殊用法：

交换两个变量的值【面试题】

a = 10
b = 20
c = b, a # 组包
print(c) # (20, 10)   -->tuple
a, b = c # 拆包 a=20  b=10 --> int
print(a, b)

#结论

标签：02,my,list,列表,print,字符串,序列,数据,字典	

From： https://www.cnblogs.com/xcq-bj/p/18301700