第四章·字符串列表元组字典集合

一：字符串的介绍：

不可变类型

<0>格式：

i ='hello'
j = "world"
m = """
Hello World"""
n = '''
i'tom is a good man'''
d = '''
I\'m a good man'''
print(n)
print(d)

<1>输入和输出：

1.输入input：

通过input完成键盘获取数据，然后保存到指定的变量中；

【注意】：input获取数据，都以字符串的方式进行保存，即使输入的是数字，那么也是以字符串方式保存。

userName = input("请输入用户名:")
print("用户名为：%s" % userName)

password = input("请输入密码:")
print("密码为：%s" % password)

2.输出print:

name = 'lisi'
job = 'student'
address = '北京市'
print("姓名是%s" % name)
print("工作是%s" % job)
print("地址是%s" % address)

<2>字符串的下标和切片：

1.字符串在内存中：

s1 = 'hello'
s2 = s1                                 # 字符串之间是可以赋值的
s3 = 'hello'
s4 = 'hello1'
print(s1, s2, s3, s4)
print(id(s1), id(s2), id(s3), id(s4))               # id()是查看地址的
# is比较的是地址部分
print(s1 is s2)               # True  
print(s3 is s2)               # True
print(s3 is s4)               # False

s1 = 'world'
print(s1, s2, s3)

1.垃圾回收机制拓展：一段时间后扫描该字符串还有指针指向，若没有，将该空间回收。

【注意】 只要内存中有所需字符串，python就会取该字符串地址，没有才去新建一个内存块去存取字符串。(python中有一个字符串保留区)

2.字符串索引机制：

• 0 ~ len(s)-1
• -len(2) ~ -1
• 

s1 = 'ABCDEFG'
print(s1[4])        # E
print(s1[0])        # A
print(s1[-3])       # E
print(s1[-1])       # G

print(len(s1))      # 通过len可以获取字符串的长度

3.切片：

序列[开始位置下标：结束位置下标：步长]

【注意】

• 不包含结束位置下标，正负数均可；
• 步长是选取间隔，正负整数均可，默认步长为1；
• 如果选取方向（下标开始到结束的方向）和步长的方向冲突，则无法选取数据；

s = 'ABCDEFG'
print(s[1:4])           # 取BCD
print(s[0:5])           # ABCDE
print(s[:5])            # 这种是默认0~5：ABCDE

print(s[-3:])           # 结果：EFG
print(s[-3:7])          # 结果：EFG

print(s[:])             # 结果相当于打印s：ABCDEFG

print(s[1:-1])          # 去掉头尾：BCDEF

x = s[:]
print(x)
print(s)
print(id(x))
print(id(s))
# 地址一样

print('@'*20)
"""
字符串变量[start:end:step]   默认是从左向右一个一个取元素
"""
s = 'ABCDEFG'
print(s[:-1:2])         # 结果：ACE
print(s[1:-1:2])        # 结果：BDF
print(s[::4])           # 结果：AE
print(s[-3::-4])        # 结果：EA

<3>字符串的常见操作：

1.关键字：

（1）获取长度：

• len():访问长度，即其中数据个数；

【注意】len（）是一个公共方法，无论字符串、列表、元组、字典都可以使用，作用相同；

（2）查找内容：

所谓字符串查找方法即是查找字符串中的位置（下标）或出现次数。

格式：字符串序列.find（子串，开始位置下标，结束位置下标）

【注意】开始与借宿位置下标可以省略，表示在整个字符串序列中查找。

• count()：返回某个子串在字符串中出现的次数；
• find（）:检查某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标；否则报错（返回-1）；
  • rfind：从右侧找，符合的返回；
• index（）:检查某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标；否则报错（返回-1）。
  • rindex：从右侧找；
    • 

"""
https://img-s-msn-com.akamaized.net/tenant/amp/entityid/AA1kdnQa.img?w=768&h=338&m=6
"""

path = 'https://img-s-msn-com.akamaized.net/tenant/amp/entityid/AA1kdnQa.img?w=768&h=338&m=6'
i = path.find('?')
print(i)
image_name = path[i+1:]
print(image_name)           # 输出结果：w=768&h=338&m=6

# 拿到图片的扩展名
n = path.rfind('.')
print(n)
a = path.rfind('?')
image_n = path[n+1:a]
print(image_n)              # 拿到img

# 未找到返回-1
m = path.find('_')
print(m)                    # 返回-1

i = path.find('img')                # 找多个字母，返回第一个字母的位置
print(i)
image_name = path[i+1:]
print(image_name)

（3）判断：

返回结果是布尔类型：True或False。

• 字符串序列.startswith（子串，开始下标，结束下标）：检查字符串是否以指定字符串开头，如果设置开始与借宿位置下标，则在指定范围内检查;
• endswith:是否以（' 内容 '）结尾；
• isalpha：是否是字母
• isdigit：是否是数字
• isalnum：是否是字母或数字或字母和数字组合；
• isspace：是否是纯空格
• isupper:是否全是大写字母组成
• islower:判断是否全小写

p = 'AA1kdnQa.img?w=768&h=338&m=6'

result = p.startswith('a')
print(result)                       # False

result1 = p.startswith('A')
print(result1)                          # True


result3 = p.endswith('m=6')
print(result3)                              # True

s = 'A1234'
# 判断纯字母
result = s.isalpha()
print(result)                       # False

# 判断是否为纯数字
re2 = s.isdigit()
print(re2)                          # False

# 判断是否为数字或字母,特殊符号就返回False
re3 = s.isalnum()
print(re3)                          # True

re4 = s.isspace()
print(re4)                          # False

a = ' '
re5 = a.isspace()
print(re5)                          # True

b = 'ABc'
# 判断是否全是大写字母组成
result0 = b.isupper()
print(result0)                      # False

# 判断是否全小写
re6 = b.islower()
print(re6)                          # False

'''
    用户名或者手机号码登录+密码：
    用户名：全部小写，首字母不能是数字，长度必须为6位以上
    手机号码：纯数字 长度11
    密码：6位数字

    以上符合条件则进入下层验证：
    判断用户+密码 是否正确

    admin123    15811119999             200325
'''
num = 0
while num < 3:
    num += 1
    name = input('请输入用户名：')
    phone = input('请输入手机号：')
    first = name[:1]
    # not first[0].isdigit()也可以写 first[0].isalpha
    if (name.islower() and not first[0].isdigit() and len(name) >= 6) and (phone.isdigit() and len(phone) == 11):
        password = input('请输入密码：')
        if len(password) == 6:
            print('登录成功')
            break
    else:
        print('用户名/手机号出错')


# 优化
'''
    用户名或者手机号码登录+密码：
    用户名：全部小写，首字母不能是数字，长度必须为6位以上
    手机号码：纯数字 长度11
    密码：6位数字

    以上符合条件则进入下层验证：
    判断用户+密码 是否正确

    admin123    15811119999             200325
'''
flag =True
while flag:
    name = input('请输入用户名：')
    phone = input('请输入手机号：')
    first = name[:1]
    # not first[0].isdigit()也可以写 first[0].isalpha
    if (name.islower() and not first[0].isdigit() and len(name) >= 6) and (phone.isdigit() and len(phone) == 11):
        while True:
            password = input('请输入密码：')
            if len(password) == 6 and password.isdigit():
                if (name == 'admin123' and phone == '15811119999') and (password == '200325'):
                    print('登录成功')
                    flag = False
                    break
                else:
                    print('密码错误，失败')
                    break
    else:
        print('用户名/手机号出错')

【注意】返回值都是布尔类型

（4）计算出现次数：

• count（）：统计指定字符的出现次数

path = 'https://img-s-msn-com.akamaized.net/tenant/amp/entityid/AA1kdnQa.img?
# 查找有几个.
a = path.count('.')
print(a)                    # 3

（5）替换内容：

• 字符串序列.replace（旧字符串,新字符串,替换次数）：默认全部替换，也可以通过count指定次数;

【注意】说明replace函数有返回值，返回值是修改后的字符串，不会改变原有字符串；替换次数如果超出子串出现的次数，表示替换所有这个子串。

（6）切割字符串：

• 字符串序列.split(分隔符，num)：返回结果是一个列表，num表示分割字符出现的次数，即将来返回数据个数num+1个；
  • rsplit（'分隔符'，maxsplit）:返回结果是一个列表，maxsplit 最多的分割次数；

【注意】会丢失分割字符

• splitlines（）：按行分割；
• partition('分隔符'):返回结果是列表，分成三部分（'第一部分'，'分隔符'，'第三部分'）
• rpartition

s = 'lisi说：张三，唱歌;张三跳舞吗？'
result = s.replace('张三','**',1)           # 1表示只替换1个
print(result)                                     # lisi说：**，唱歌;张三跳舞吗？
# 用 正则表达式 替换多个或者 循环+列表

m = 'lisi 张三 王五'
result1 = m.split(' ')
print(result1)                                  # ['lisi', '张三', '王五']
result2 = m.rsplit(' ',1)
print(result2)                                  # ['lisi 张三', '王五']

print('@'*20)
result0 = m.partition(' ')                      # ('lisi', ' ', '张三 王五'):中间是分割符，两边是分割出来的内容
print(result0)


print('@'*20)
n = """lisi,今天天气贼拉好，出来玩不？
到中央大街，先去商城，然后去游戏厅，
你有时间吗？
收到请回call
"""
result3 = n.splitlines()
print(result3)                                  # ['lisi,今天天气贼拉好，出来玩不？', '到中央大街，先去商城，然后去游戏厅，', '你有时间吗？', '收到请回call']

（7）修改大小写：

• capitalize()：将字符串第一个字符转换成大写；
• title（）:将字符串每个单词首字母转换为大写；
• upper（）：将字符串小写转大写；
• lower():将字符串中大写转小写；

s = 'hello world'
result = s.title()
print(result)                           # Hello World

result1 = s.upper()
print(result1)                          # HELLO WORLD

s1 = 'Hello WORLD'
result2 = s1.lower()
print(result2)                          # hello world

result3 = s.capitalize()
print(result3)                          # Hello world

（8）空格处理：

• strip():去掉左右全部空格；
  • lstrip（）:去掉左侧空格；
  • rstrip（）：去掉右侧空格；
• 字符序列.center(长度，填充字符)；
  • ljust(长度，填充字符)
  • rjust(长度，填充字符)

# print(len(input('用户名：')))                                # 若输入中含空格也会计算入长度，例如：输入lisi空格空格空格；输出长度就是7

# 空格处理
name = '  adimn  '
print(len(name))                                # 9
s = name.strip()
print(len(s))                                   # 5
print(s)                                        # admin

s1 = name.lstrip()
print(len(s1))                                  # 7
print(s1)                                       # admin空格空格

s2 = name.rstrip()
print(len(s2))                                  # 7
print(s2)                                       # 空格空格admin

（9）字符串拼接：

• 字符或子串.join(多字符串组成的序列):用一个字符或子串合并字符串，即是将多个字符串合并为一个新的字符串；

【注意】python中，字符串是不可变的！所有字符串相关方法，都不会改变原有字符串，而是返回一个结果，在这个新的返回值里，保留了执行后的结构！

"""
    模拟文件上传，键盘输入上传文件的名称，判断文件名是否大于6位以上,扩展名是否是：jpg/gif/png格式
    如果不是则提示上传失败
    若名字不满足条件，而扩展名满足条件则随机生成一个6位数字组成的文件名，打印成功上传xxxxxx.png
"""
# 方法一
import random
name = input('请输入上传文件名称：')
r = name.rfind('.')
n = name[:r]
extension = name[r+1:]

if extension == 'jpg' or extension == 'gif' or extension == 'png':
    # 判断文件名字
    if len(n) < 6:
        # 重新构建名字
        number = random.randint(100000, 999999)
        name = str(number) +'.' + extension
    print('成功')
    print(name)

else:
    print('失败')
# 方法二
import random
file = input('请输入文件名称：')
if file.endswith('jpg') or file.endswith('gif') or file.endswith('png'):
    # 判断文件名称
    i = file.rfind('.')
    name = file[:i]
    if len(name) < 6:
        number = random.randint(100000, 999999)
        file = str(number) + file[i:]
    print('成功%s'% file)
else:
    print('失败')

# 字母数字的组合    验证码
filename = ''
s = 'abcdefjhijklmnopqrstuvwxyzABCDEFGHIZKLMNOPQRSTUVWXYZ'
for i in range(6):
    index = random.randint(0, len(s)-1)
    filename += s[index]
print(filename)



"""
    模拟文件上传，键盘输入上传文件的名称，判断文件名是否大于6位以上,扩展名是否是：jpg/gif/png格式
    如果不是则提示上传失败
    若名字不满足条件，而扩展名满足条件则随机生成一个6位数字组成的文件名，打印成功上传xxxxxx.png
"""
import random
# 字母数字的组合
s = 'abcdefjhijklmnopqrstuvwxyzABCDEFGHIZKLMNOPQRSTUVWXYZ'
file = input('请输入文件名称：')
if file.endswith('jpg') or file.endswith('gif') or file.endswith('png'):
    # 判断文件名称
    i = file.rfind('.')
    name = file[:i]
    if len(name) < 6:
        filename = ''
        for a in range(6):
            index = random.randint(0, len(s) - 1)
            filename += s[index]
        file = filename + file[i:]
    print('成功%s' % file)
else:
    print('失败')

二：列表的介绍：

列表：数据可修改

1.格式：

• [元素1，元素2，元素3，......，元素n]

• [[ ],[ ],[ ]]

• 例：

  tmp = ['lisi', 180, 65.0]

【注意】列表可以一次性存储多个数据，且可以是不同类型的；

2.使用下标获取列表元素：

list1 = []                                  # 空列表:[]
print(type(list1))                          # <class 'list'>

# 有内容列表
list2 = ['李四', 18, '学生', '朝阳中学', '14班', '第3排座位']
print(list2[2])                             # 学生
print(list2[-4])                            # 学生

# 切片
print(list2[:2])                            # ['李四', 18]
print(list2[-4:3])                          # ['学生']
print(list2[::-2])                          # ['第3排座位', '朝阳中学', 18]

'''
    例：列表可直接参与循环
'''
s = 'hell1ow3or2ld4'
# for i in s:
#     print(i)
num = 0
for i in s:
    if i.isdigit():
        num += int(i)       
print(num)                          # 10

3.增删查改：

3.1.增:

• append（数据）：列表结尾追加数据
• extend(数据)：列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表；
• insert(位置下标，数据)：指定位置新增数据；

【注意】

• 列表追加数据时，直接在原列表里面追加指定数据，即修改了原列表，故列表为可变类型；
• append()追加数据是一个序列，则追加整个序列到列表；
• extend()追加的序列，会被逐一拆开，再追加到列表结尾；

list1 = []
# append('内容'),extend('内容')添加
list1.append('lisi')
print(list1)                        # ['lisi']
list1.append(['zhangsan',18,'wangwu'])
print(list1)                        # ['lisi', ['zhangsan', 18, 'wangwu']]

list1.extend('xiaoming')
print(list1)                        # ['lisi', ['zhangsan', 18, 'wangwu'], 'x', 'i', 'a','m', 'i', 'n', 'g']
list1.extend(['xdd','qws'])
print(list1)                        # ['lisi', ['zhangsan', 18, 'wangwu'], 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g', 'xdd', 'qws']

list1.insert(2,'sa')             
print(list1)                        # ['lisi', ['zhangsan', 18, 'wangwu'], 'sa', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g', 'xdd', 'qws'] 

• 例：

"""
    买多件：
    商品名称，价格，数量
    要用到列表的嵌套
"""
arr = []
flag = True
while flag:
    name = input('请输入名称：')
    price = input('请输入价格：')
    num = input('请输入数量：')
    list1 = [name, price, num]
    arr.append(list1)

    question = input('是否继续（N：否）：')
    if question.lower() == 'n':
        flag = False
print(arr)                      # 最终结果：[[],[],[]......[]]
print('*-'*20)
# print('名称\t价格\t数量')
# 遍历列表arr中元素
for list1 in arr:
    print(list1)
    print('{}\t{}\t{}'.format(list1[0], float(list1[1]), int(list1[2])))

3.2.删：

• del 目标
• pop(下标)：删除指定下标数据（默认最后一个），并返回该数据；
• remove(数据):移除列表中某个数据的第一个匹配项；
• clear（）：清空列表；

3.3.查：

• index(数据，开始位置下标，结束位置下标):返回指定数据所在位置下标；
• count():统计指定数据在当前列表中出现次数；
• len(数据序列)

3.4.改：

• 修改指定下标数据；
• 逆置：reverse（）
• 排序:列表序列.sort(key = None,reverse = False)

【注意】reverse表示排序规则，reverse=True降序，反之升序（默认）；

list1 = ['lisi', ['zhangsan', 18, 'wangwu'], 'sa']
# 修改指定下标数据
list1[1] = 'wangwu'
print(list1)    # ['lisi', 'wangwu', 'sa']

# 逆序reverse
list2 = [1,5,3,4,7,2]
list2.reverse()
print(list2)    # [2, 7, 4, 3, 5, 1]

# 排序sort
list2.sort()
print(list2)  # 默认升序[1, 2, 3, 4, 5, 7]
list2.sort(reverse=True)
print(list2)  # 降序[7, 5, 4, 3, 2, 1]

4.判断是否存在：

• in:判断指定数据在某个列表序列，在返回True；
• not in:判断指定数据不在某个列表序列，不在返回True；

5.复制：

• copy()

6.循环遍历：

• while:

list1 = ['lisi', ['zhangsan', 18, 'wangwu'], 'sa']
i = 0
while i < len(list1):
    print(list1[i])
    i += 1

• for:

list1 = ['lisi','zhangsan','sa']
for i in list1:
    print(i)

【注意】一般优先考虑for循环；

7.综合应用--随机分配办公室：

需求：有三个办公室，8位老师，8位老师随机分配到3个办公室；

三：元组(tuple）:

一个元组可以存储多个数据，元组内的数据是不能修改的。

1.格式：

• （元素1，元素2，...，元素n）

2.常见操作：

• 按下标查找数据

t1 = (22,'hello',3.9,66,77,'mkl')
print(t1[3])

• index（）：查找某个数据，如果数据存在返回对应下标，否则报错；

t1 = (22,'hello',3.9,66,77,'mkl')
print(t1.index(3.9))

【注意】元组数据不支持修改，只支持查找；

• count():统计某个数据在当前元组出现次数；

t1 = (22,'hello',3.9,66,77,'mkl','hello')
print(t1.count('hello'))

• len（）:统计元组数据的个数；

t1 = (22,'hello',3.9,66,77,'mkl','hello')
print(len(t1))

【注意】元组修改只能这样：

t1 = ('aa','bb','cc','dd')
# t1[0] = 'aaa'    #TypeError: 'tuple' object does not support item assignment

t2 = ('aa','bb',['cc','dd'])
print(t2[2][0])          # cc
t2[2][0] = 'hello'
print(t2)                # ('aa', 'bb', ['hello', 'dd'])

四：字典(dict)：

可变数据类型

1.特点：

• 符号大括号；
• 数据为键值对形式出现；
• 各个键值对之间用逗号隔开；

2.常见操作：

2.1.增：

• 字典序列[key] = 值

【注意】如果key存在则修改这个key值，若key值不存在则新增此键值对；

2.2.删：

• del()/del:删除字典或删除字典中指定键值对；
• clear():清空字典；

2.3.改：

• 字典序列[key] = 值

【注意】如果key存在则修改这个key对应的值；若key不存在则新增键值对；

2.4.查：

• key值查找

【注意】如果当前key存在，则返回对应的值，反之报错；

• 字典序列.get(key，默认值)

【注意】如果当前查找key不存在则返回第二个参数（默认值），如果省略第二个参数，则返回None；

• keys()
• values()
• items()

3.循环遍历：

3.1.遍历字典key：

3.2.遍历字典的value：

3.3.遍历字典的元素：

3.4.遍历字典键值对：

• 将得到的数据拆包；

五.集合（set）：

可变数据类型；

【注意】

• 集合中没有重复数据，默认有去重功能；
• 集合无顺序；

1.创建：

创建集合使用{}或set（），但是如果创建空集合只能使用set()，因为{}用来创建空字典。

2.常见操作方法：

2.1.增加：

• add()：增加单一数据；
• update():追加的数据是序列；

【注意】因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进行任何操作；

2.2.删除：

• remove():删除集合中的指定数据，如果数据不存在则报错；
• discard():删除集合中的指定数据，如果数据不存在也不会报错；
• pop():随机删除集合中某个数据，并返回这个数据；

2.3.查找：

• in:判断数据在集合序列；
• not in:判断数据不在集合序列；