3. 字符串、列表、元组、字典

3.1 for循环

for 临时变量 in 列表或者字符串等可迭代对象:
循环满足条件时执行的代码

3.2 break和continue

• 1 break 立刻结束break所在的循环

• for 循环中
• while循环中

• 2 continue 用来结束本次循环，紧接着执行下一次的循环

• for 循环中
• while循环中

break/continue只能用在循环中，除此以外不能单独使用

break/continue在嵌套循环中，只对最近的一层循环起作用

3.3字符串介绍

双引号或者单引号中的数据，就是字符串

3.4字符串输出

3.5字符串输入

3.6下标和切片

• 1 下标索引

python中下标从 0 开始

• 2 切片

• 切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

• 切片的语法：[起始:结束:步长]

注意：选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，步长表示选取间隔

• 字符串名[m:n:k] 来表示从下标为m到下标为n，每k个取一个

索引是通过下标取某一个元素

切片是通过下标去某一段元素

str1 = "hello world"

# print(str1[4])   # o
# print(str1[2:7])  # llo w
# print(str1[:3])   # hel   # 第一个m省略表示从第一个元素开始取
# print(str1[3:])    # lo world   # n省略表示从下标为m开始取到最后一个元素
# print(str1[:])   # "hello world"
# print(str1)  # "hello world"
# print(str1[::2])  # hlowrd


# print(str1[::-1])   # dlrow olleh   将字符串进行反转，逆转，逆序，倒序
# print(str1[-3])   # 取倒数第三个字符
# print(str1[2:-3])   # llo wo
# print(str1[-8:8])  # lo wo

3.7字符串常见操作

mystr = ‘hello world itcast and itcastcpp’

• mystr.find(“it”) 在mystr字符串中找"it"这个子串，找到就返回第一次出现时候的下标，找不到返回-1

• mystr.index(“it”) 在mystr字符串中找"it"这个子串，找到就返回第一次出现时候的下标，找不到则报错

• mystr.count(“it”) 在mystr字符串中找"it"这个子串，找到就返回出现的次数，找不到返回0

• mystr.isdigit() 判断mystr字符串是不是一个纯数字的字符串，如果是返回True，否则返回False

• mystr.isalpha() 判断mystr字符串是不是一个纯字母的字符串，如果是返回True，否则返回False

• mystr.isspace() 判断mystr字符串是不是一个纯空格的字符串，如果是返回True，否则返回False

• mystr.startswith(“ab”) 判断mystr字符串是不是以子串ab开始的，如果是返回True，否则返回False

• mystr.endswith(“ab”) 判断mystr字符串是不是以子串ab结尾的，如果是返回True，否则返回False

• mystr.replace(子串1, 字符串2) 返回一个新字符串，把mystr中的子串1，全部替换成字符串2

• mystr.strip() 返回一个新字符串，去掉mystr字符串中的前后空格

• mystr.lstrip() 返回一个新字符串，去掉mystr字符串中的前空格

• mystr.rstrip() 返回一个新字符串，去掉mystr字符串中的后空格

• mystr.split(子串) 返回一个列表，把mystr按照子串进行分割成若干部分，每个部分作为列表中的每个元素，这个子串最终消失

• mystr.partition(子串) 返回一个元组，把mystr按照子串进行分割成3个部分，子串作为第2个元素，子串前面的字符串作为元组第一个元素，子串后面的字符串作为元组第3个元素

• mystr.upper() 返回一个新字符串，把字符串中所有的字母变成大写字母

• mystr.lower() 返回一个新字符串，把字符串中所有的字母变成小写字母

• mystr.capitalize() 返回一个新字符串，把字符串中第一个字母转换成大写，其余小写

• mystr.title() 返回一个新字符串，把字符串中每个单词第一个字母转换成大写，其余小写

• mystr.swapcase() 返回一个新字符串，把字符串中字母进行大小写互换

• mystr.center(100) 返回一个新字符串，让mystr在100个字符的长度中做居中效果

• len(mystr) 返回出字符串中字符的个数

mystr = 'hello world itcast and itcastcpp'

# print(mystr.find("xxx"))
# print(mystr.index("xxx"))
# print(mystr.count("ito"))

# print(mystr.split(" "))  # ['hello', 'world', 'itcast', 'and', 'itcastcpp']
# print(mystr.split("it"))   # ['hello world ', 'cast and ', 'castcpp']

# file_name = "xxx.html"
# print(file_name.endswith(".py"))


lines = "GET /index.html 200OK"
# print(lines.split(" "))

lines = "hello "
print(len(lines))

3.8 列表介绍

namesList = ['xiaoWang','xiaoZhang','xiaoHua']

比C语言的数组强大的地方在于列表中的元素可以是不同类型的

3.9 列表的循环遍历

• 1 使用for循环
• 2 使用while循环

name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu"]   # 定义一个列表

# print(name_list)
# print(type(name_list))  # <class 'list'>
# print(name_list[1])  # 获取到下标为1的元素


for i in name_list:   # for循环遍历这个列表
    print(i)


# i = 0
# while i < 4:  # while循环遍历这个列表
#     print(name_list[i])
#     i += 1
### 3.10 列表的常用操作 ###

• 增

• append
• extend
• insert

• 改
• 查

• in not in
• index count

• 删 remove del clear
• 排序 sort reverse

name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
print(name_list)
# 增
# name_list.append("liqi")   # 在列表最后追加一个元素
# name_list.insert(1, "liqi")   # 在下标为1的位置插入一个数据"liqi"
# name_list.extend(["liqi", "baba"])
# name_list.append(["liqi", "baba"])   # ['zhangsan', 'lisi', 'wangwu', 'zhaoliu', ['liqi', 'baba']]
# print(name_list)


# 删除
# name_list.remove("lisi")   # 删除"lisi"这个元素
# aaa = name_list.pop(2)    # 如果没有参数默认删除最后一个元素， 如果传了一个数字，表示删除这个下标所在的元素, 这个pop功能会返回（得到）这个删除的数据
# print(name_list)
# print(aaa)

# name_list.clear()   # 清空列表中所有数据
# print(name_list)

del name_list[2]
print(name_list)

name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
print(name_list)


# 改
# name_list[1] = "liqi"
# print(name_list)

# 查
# print(name_list[2])  # wangwu
# print("liqi" in name_list)   # False
# print("liqi" not in name_list)  # True
#
# if "liqi" not in name_list:
#     ....
# 问："lisi"在列表中出现多少次   name_list.count("lisi")
# print(name_list.count("lisi"))
# 问："lisi"在列表中的下标是多少？   name_list.index("lisi")
# print(name_list.index("lisi"))


nums = [20, 99, 1020, -9, 6, 1]

# print(nums)  # [20, 99, 1020, -9, 6, 1]
# nums.sort()   # 排序，从小到大排
# print(nums)  # [-9, 1, 6, 20, 99, 1020]
# nums.reverse()    # 列表逆转、倒序
# print(nums)  # [1020, 99, 20, 6, 1, -9]

# print(nums[::-1])
# print(nums[:3])

3.11 列表的的嵌套

	"""
[ [], [] , []]


一个学校，有3个办公室，现在有8位老师等待工位的分配，请编写程序，完成随机的分配
"""
import random

offices = [[], [], []]   # 为什么里面每一个办公室也是一个列表？因为：一个办公室可以进入多个老师
teachers = ["A", "B", "C", "D", "E", "F", "G", "H"]


for i in teachers:   # i就是每一个老师
    offices[random.randint(0, 2)].append(i)

# print(offices)
# [['C', 'F', 'G'], ['A', 'D', 'E', 'H'], ['B']]

for i in offices:  # print要打印多少次取决于多少办公室，所以应该遍历办公室列表
    # i是offices中的每一个小列表，即每一个办公室
    # 提示： i是offices的元素,就可以通过.index()这个功能来求到i所在的下标
    print("第%s间办公室的老师有：" % (offices.index(i)+1), end="")

    for j in i:  # i是offices中的每一个小列表，即每一个办公室
        # j 是i列表中的每一个老师
        print(j, end="\t")

        # 里层的这个for一旦执行完毕说明老师打印完毕了，说明一行已经结束

    print()

3.12 元组

Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号
访问 count index

"""
元组作用：展示多个数据
特点： 元组元素不可修改，（不能添加、删除、修改数据）


tup3 = (100,)
"""

tup = (10, 20, 30, 40, "abc", 40, [100, 200, 300])

# print(tup, type(tup))


# 查：
# print(tup[1])
# print(40 in tup)
# print(40 not in tup)
# print(tup.count(40))
# print(tup.index(40))

# tup[1] = 300   # 报错

# print(tup[6])  # [100, 200, 300]
# print(tup[6][0])  # 100
# tup[6][0] = 10000
# print(tup)  # (10, 20, 30, 40, 'abc', 40, [10000, 200, 300])
# print(100 in tup)  # False
# print(100 in tup[6])  # True


tup2 = (100)
print(tup2, type(tup2))  # 100 <class 'int'>
tup3 = (100,)
print(tup3, type(tup3))  # (100,) <class 'tuple'>

3.13 字典介绍

3.14 字典的常见操作1

• 查看元素
• 修改元素
• 增加元素
• 删除元素

• del
• clear

# list1 = [27, "python", "AI"]
#
# print(list1["job"])

dic = {"age": 27, "job": "AI", "name": "python"}

print(dic, type(dic))


# 查
# print(dic["name"])  # python
# print(dic["age"])  # 27
# print(dic["age1"])  # 报错
# print(dic.get("name"))  # python
# print(dic.get("age1"))   # None

# 删除
del dic["age"]
print(dic)  # {'job': 'AI', 'name': 'python'}


# 添加
dic["age"] = 28
print(dic)


# 修改
dic["age"] = 29
print(dic)

3.15 字典的常见操作2

• lens()
• keys
• values
• items

"""

{"name": "python", "age": 27, "job": "AI"}
{键：值，键：值，键：值}
{key: value, key: value, key: value}


如何获取字典中的某个值？
字典名[键名]


键名的数据类型可以是：字符串， 数字， 元组
值可以是其他的任意数据
"""

# list1 = [27, "python", "AI"]
#
# print(list1["job"])

dic = {(10, 20): 27, "job": "AI", "name": "python"}

print(dic, type(dic))
print(dic[(10, 20)])

3.16 字典的遍历

通过for … in … 我们可以遍历字符串、列表、元组、字典等

• 遍历key
• 遍历value
• 遍历元素
• 遍历key-value键值对

dic = {"age": 27, "job": "AI", "name": "python"}

# for i in dic:
#     print(i)

# for i in dic.keys():   # 遍历字典的键
#     print(i)

# for i in dic.values():   # 遍历字典的值
#     print(i)

# for i in dic.items():  # 遍历字典的键值对
#     print(i)   # i就是每一个键值对组成的元组


dic = {"age": 27, "job": "AI", "name": "python"}

for key, value in dic.items():  # 遍历字典的键值对
    print(key)   # key就是每一个键
    print(value)   # value就是每一个值


# a, b = (10, 20)  # 拆包
# print(a)
# print(b)

• enumerate()
  enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

chars = ['a', 'b', 'c', 'd']
for i, chr in enumerate(chars):
	print i, chr
结果：
0 a
1 b
2 c
3 d

3.17 判断是否是闰年

"""

判断是否是闰年
2、请实现一个判断用户输入的年份是否是闰年的程序
提示：
1.能被400整除的年份      if num % 400 == 0: 
2.能被4整除，同时不能被100整除的年份
以上2种方法满足一种即为闰年

"""


num = int(input("请输入一个年份"))

if num % 400 == 0 or (num % 4 == 0 and num % 100 != 0):
    print("%s是闰年" % num)
else:
    print("%s是平年" % num)

3.18 公共方法

• 运算符

• python内置函数

• cmp
• len
• max
• min
• del

• 多维列表/元祖访问的示例