day08_python_高级变量类型（非数字型）

1.列表（类似于数组）

序列是 Python 中最基本的数据结构。
序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。
Python 有 6 个序列的内置类型，但最常见的是列表和元组。
列表都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可

name_list = ["张三", "李四", "王五"]
print(name_list[1])

李四

方法：


用法：

hello_list = ["牛牛", "猪猪", "兔兔"]
name_list = ["张三", "李四", "王五"]
print(name_list)
# 取值和取索引
print(name_list[1])
print(name_list.index("李四"))  # 取索引
# 修改
name_list[2] = "大白"
print(name_list)
# 增加
name_list.append("小黑")  # 在列表末尾追加数据
print(name_list)

name_list.insert(2, "王五")  # 在某个位置插入数据
print(name_list)

name_list.extend(hello_list)  # 把另外的列表内容完整的追加在当前列表后面
print(name_list)
# 删除
name_list.remove("小黑")  # 如果有两个小黑，默认删除第一个
print(name_list)

name_list.pop()  # pop方法默认把列表最后一个元素删除
print(name_list)
name_list.pop(3)  # pop方法可以指定要删除元素的索引
print(name_list)

name_list.clear()  # 清空列表
print(name_list)

['张三', '李四', '王五']
李四
1
['张三', '李四', '大白']
['张三', '李四', '大白', '小黑']
['张三', '李四', '王五', '大白', '小黑']
['张三', '李四', '王五', '大白', '小黑', '牛牛', '猪猪', '兔兔']
['张三', '李四', '王五', '大白', '牛牛', '猪猪', '兔兔']
['张三', '李四', '王五', '大白', '牛牛', '猪猪']
['张三', '李四', '王五', '牛牛', '猪猪']
[]

进程已结束,退出代码0

del 删除（不建议使用）

name_list=["张三", "李四", "王五"]
del name_list[1]
print(name_list)

['张三', '王五']

列表的数据统计

name_list = ["张三", "李四", "王五", "李四"]
list_len = len(name_list)
print(name_list.count("李四"))
print("列表中包含 %d 个元素" % list_len)

2
列表中包含 4 个元素

排序

name_list = ["z张三", "l李四", "w王五"]
num_list = [5, 7, 4, 9, 13]
# 升序
name_list.sort()  # 对字母排序
num_list.sort()
print(name_list)
print(num_list)
# 降序
num_list.sort(reverse=True)
name_list.sort(reverse=True)
print(name_list)
print(num_list)
# 逆序（反转）
name_list.reverse()
num_list.reverse()
print(name_list)
print(num_list)

['l李四', 'w王五', 'z张三']
[4, 5, 7, 9, 13]
['z张三', 'w王五', 'l李四']
[13, 9, 7, 5, 4]
['l李四', 'w王五', 'z张三']
[4, 5, 7, 9, 13]

关键字、函数和方法
关键字 是python内置的、具有特殊意义的标识符，关键字后面不需要使用括号
函数 封装了独立功能，可以直接调用
方法 和函数类似，同样封装了独立的功能，需要通过对象来调用——对象.方法名（参数）

列表的循环遍历

name_list = ["张三", "李四", "王五", "李小四"]
# 使用迭代遍历列表
for my_name in name_list:  # 每循环一次，数据保存在my_name 变量里
    print("我的名字叫 %s" % my_name)

我的名字叫 张三
我的名字叫 李四
我的名字叫 王五
我的名字叫 李小四

列表应用场景
1.列表存储相同类型的数据
2.通过迭代遍历，在循环体内部，针对列表中的每一项元素，执行相同的操作

注意：python的列表可以存储不同类型的数据

2.元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改，可以起到保护数据的作用
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
元组使用小括号 ( )，列表使用方括号 [ ]。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
索引从0开始

empty_tuple = ()  # 创建空元组
single_tuple = (5, )  # 元组中只包含一个元素时，需要在元素后面添加逗号,否则括号会被当作运算符使用

info_tuple = ("zhangsan", 18, 1.75, 1.75)
print(info_tuple[0])  # 取值
print(info_tuple.index(18))  # 取索引
print(info_tuple.count(1.75))  # 统计某个元素的个数
print(len(info_tuple))  # 统计元组中元素的个数

输出

zhangsan
1
2
4

循环遍历和字符串的拼接

info_tuple = ("小明", 18, 1.75)
for my_info in info_tuple:

    print(my_info)
print("%s的年龄是%d岁，身高是%0.2f米" % info_tuple)

小明
18
1.75
小明的年龄是18岁，身高是1.75米

格式化字符后面的’()'本质上就是元组

info_str = "%s的年龄是%d岁，身高是%0.2f米" % info_tuple
print(info_str)

小明的年龄是18岁，身高是1.75米

元组和列表之间的转换

num_list = [1, 3, 6]  # 定义一个列表
one = type(num_list)  # one来接收数据
print(one)

num_list = tuple(num_list)  # 强制转换为元组-----tuple（）
two = type(num_list)
print(two)

num_list = list(num_list)  # 强制转换为列表-----list（）
three = type(num_list)
print(three)

<class 'list'>
<class 'tuple'>
<class 'list'>

3.字典

字典是另一种可变容器模型，且可存储任意类型对象
键必须是唯一的，但值则不必
值可以取任何数据类型，但键必须是不可变的，如字符串，数字
字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中

xusong = {"name": "许嵩",
          "age": 35,
          "gender": True,
          "height": 1.81,
          "weight": 120}

print(xusong)
# 取值
print(xusong["name"])
# 修改和增加
xusong["name"] = "小嵩嵩"  # 修改
xusong["where"] = "安徽"  # 新增
print(xusong)
# 删除
xusong.pop("where")
print(xusong)

{'name': '许嵩', 'age': 35, 'gender': True, 'height': 1.81, 'weight': 120}
许嵩
{'name': '小嵩嵩', 'age': 35, 'gender': True, 'height': 1.81, 'weight': 120, 'where': '安徽'}
{'name': '小嵩嵩', 'age': 35, 'gender': True, 'height': 1.81, 'weight': 120}

其他操作

xiaoming = {"name": "小明",
            "age": 18}
print(xiaoming)
# 统计键值对数量
one = len(xiaoming)
print(one)

# 合并字典并更新
qita = {"height": 100,
        "age": 20}
xiaoming.update(qita)
print(xiaoming)

# 清空字典
xiaoming.clear()
print(xiaoming)

输出

{'name': '小明', 'age': 18}
2
{'name': '小明', 'age': 20, 'height': 100}
{}

循环遍历

xusong = {"name": "许嵩",
          "age": 35,
          "height": 1.81,
          "weight": 120}
for k in xusong:  #k是每一次循环中获取的键值对的key
    print("%s - %s" % (k, xusong[k]))

name - 许嵩
age - 35
height - 1.81
weight - 120

将多个字典放在一个列表中

card_list = [
    {"naem": "小明",
     "qq": 123456,
     "phone": 554466},
    {
        "naem": "小张",
        "qq": 11111,
        "phone": 77777
    }
]

for card_info in card_list:
    print(card_info)

{'naem': '小明', 'qq': 123456, 'phone': 554466}
{'naem': '小张', 'qq': 11111, 'phone': 77777}

4.字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号( ’ 或 " )来创建字符串。
创建字符串很简单，只要为变量分配一个值即可

定义和遍历字符串

str1 = "hello world"
str2 = "你是 '猪猪' "
str3 = '你是"猪猪"'
print(str1, str2, str3)
print(str1[6])

for char in str2:  # 遍历str2
    print(char)

字符串的统计操作

str1 = "hello world"
# 统计字符串长度
print(len(str1))

# 统计某个字符串出现的次数
print(str1.count("ll"))

# 某个字符串出现的位置
print(str1.index("w"))

字符串的常用操作
方法：

# 判断空白字符
str1 = " \t\n\r "
print(str1.isspace())

# 只包含数字返回True
# 都不能判断小数
num_str = "\u00b2"
print(num_str.isdigit())  # 全角数字、（2）、unicode\u00b2
print(num_str.isdecimal())  # 全角数字
print(num_str.isnumeric())  # 全角数字、汉字数字

hello_str = "hello world"
# 判断是否以指定的字符串开始
print(hello_str.startswith("he"))

# 判断是否以指定的字符串结束
print(hello_str.endswith("ld"))

# 查找指定字符串
print(hello_str.find("ll"))  # 查找的字符串不存在时返回-1

# 替换字符串
# replace 会返回一个新的字符串，但不会修改原有字符串内容
print(hello_str.replace("world", "python"))
print(hello_str)

True
True
False
True
True
True
2
hello python
hello world

进程已结束,退出代码0

文本对齐

poem = ["题都城南庄",
        "崔护",
        "去年今日此门中",
        "人面桃花相映红",
        "人面不知何处去",
        "桃花依旧笑春风"]
for p in poem:  # 居中对齐
    print(p.center(5))

for p in poem:  # 左对齐
    print(p.ljust(5))

for p in poem:  # 右对齐
    print(p.rjust(5))

去除空白字符

poem = ["\t\n题都城南庄",
        "崔护",
        "去年今日此门中",
        "人面桃花相映红\t\n",
        "人面不知何处去",
        "桃花依旧笑春风"]
for str3 in poem:
    print("|%s|" % str3.strip().center(10))

|  题都城南庄   |
|    崔护    |
| 去年今日此门中  |
| 人面桃花相映红  |
| 人面不知何处去  |
| 桃花依旧笑春风  |

拆分和连接

poem1 = "去年今\t日此门中 人面桃花相映红\t\n人面不知何处\t去桃花依旧笑春风"
print(poem1)
# 拆分字符串
print(poem1.split())
# 合并字符串
print("".join(poem1))

去年今	日此门中 人面桃花相映红	
人面不知何处	去桃花依旧笑春风
['去年今', '日此门中', '人面桃花相映红', '人面不知何处', '去桃花依旧笑春风']
去年今	日此门中 人面桃花相映红	
人面不知何处	去桃花依旧笑春风

字符串的切片

num = "0123456789"  # 0开始
l0 = num[2:6]  # 2开始之后，6结束之前
print(l0)
l1 = num[2:]  # 截取2到结尾
print(l1)
l2 = num[0:6]  # 开始到5
print(l2)
l3 = num[:]  # 完整字符串
print(l3)
l4 = num[::2]  # 从开始位置每隔一个字符截一次
print(l4)
l5 = num[1::2]  # 从1开始位置每隔一个字符截一次
print(l5)
l6 = num[2:-1]  # 从2开始，不包含倒数第一个字符串
print(l6)
l7 = num[-2:]  # 截取字符串末尾两个字符
print(l7)
l8 = num[::-1]  # 字符串的逆序,-1是步长
print(l8)

2345
23456789
012345
0123456789
02468
13579
2345678
89
9876543210

4.公共方法和变量高级

python内置函数

注意：字符串 比较符合以下规则:“0”<“A”<“a”

end = "老婆" > "老公"
# \u8001\u5a46\u000d\u000a
# \u8001\u516c\u000d\u000a
print(end)

end = "1" > "a"
print(end)

True
False

运算符

for 循环

# for循环找得到就break跳出循环，找不到就进入else
for num in [1, 2, 3, 4]:
    print(num)
    if num == 4:
        break
else:
    print("找不到")

print("循环结束")

1
2
3
4
循环结束

进程已结束,退出代码0

实例

student = [
    {"name": "小黑"},
    {"name": "小白"}
]
find_name = "小花"

for stu_dict in student:
    print(stu_dict)
    if stu_dict["name"] == find_name:
        print("已找到 %s 同学" % find_name)
        break
else:
    print("没有找到该同学")

print("循环结束")

{'name': '小黑'}
{'name': '小白'}
没有找到该同学
循环结束

注意：如果else在if下面，则每次if判断都会返回结果

student = [
    {"name": "小黑"},
    {"name": "小白"}
]
find_name = "小花"

for stu_dict in student:
    print(stu_dict)
    if stu_dict["name"] == find_name:
        print("已找到 %s 同学" % find_name)
        break
    else:
        print("没有找到该同学")

print("循环结束")

{'name': '小黑'}
没有找到该同学
{'name': '小白'}
没有找到该同学
循环结束