python-基本数据类型与内置方法
1.数据类型内置方法理论
1.每一种数据类型本身都含有一系列的操作方法，内置方法是其本身自带的功能，是其中最多的。
2.python中数据类型调用的内置方法的统一句式为>>>:句点符(在数类型之后)
句式:数据类型.字符串内置方法
eg:str.字符串内置方法
ps:字符串内容较多，应该联系之前的内容系统学习，并且多练习熟能生巧。
2.数据类型之整形
顾名思义就是整数，eg：年龄、年份、人数。
代码用int来表示
内置方法：
1.类型转换（将其他类型转换成整形）
语法结构: 变量名 = int（其它数据类型） print(变量名)
1.1浮点型转换成整形: 只会取前面的整数部分
num = int(11.11)
print(num) # 11
num = int(11.88)
print(num) # 11
1.2 字符串转成整形: 字符串内部是整数才可以，小数不行
s = '11'
print(int(s)) #11
s = '11.11'
print(int(s)) #报错
2进制数转换
2.1十进制转其他进制:
"""
转二进制:bin，转八进制:oct，转十六进制；数字开头是0b是二进制，开头是0o是八进制，0x是十六进制
"""
print(bin(100)) # 0b1100100
print(oct(100)) # 0o144
print(hex(100)) # 0x64
2.2 其他进制转十进制：格式:print(int('需要转换的其他进制数据'， 进制数 ))
print(int('0b1100100', 2)) # 100
print(int('0o144', 8)) # 100
print(int('0x64', 16)) # 100
3.数据类型之浮点型
大白话意思就是小数，eg：体重、身高、薪资
weight = 72.5
height = 182.3
salary = 0.3
内置方法
1.类型转换
语法结构: float(其他数据类型)
1.1 整形转化成浮点型：小数点后面增加一个0
print(float(11)) # 11.0
1.2 字符串转化成浮点型: 字符串里面是整形，转换成浮点型之后小数点后面加一个0，字符串里面是小数直接去掉单引号转化成浮点型。
print(float('11.11')) # 11.11
print(float('11')) # 11.0
2.python对数字敏感程度
python对数字敏感程度较低，如果需要进行计算需要借助模块numpy
4.数据类型之字符串str
文本类型的数据（不包含整形、浮点型）的数据类型，用引号引起来
eg：
name = 'Max'
hobby = 'soccer'
字符串的几种定义方式：
name = 'max'
name1 = 'max'
name2 = '''max'''
name3 = """max"""
如何区分？
编写字符串的文本当中也会遇到引号，为避免冲突，有多种表达方式
eg： info = "jason老实说'年轻不是挥霍的资本'"
如何区分三引号是字符串还是注释？
若字符串左侧有赋值符号和变量名，是字符串，若没有则是注释。
内置方法：
1.类型转化
语法结构：str(其它数据类型) （可以转化任意数据类型，只需在前面加引号即可）
print(str(11)) # '11'
print(str('11.11')) # '11.11'
print(str([1, 2, 2])) # '[1, 2, 2]'
print(str({'name': 'max',})) # '{'name': 'max'}'
2.索引取值
索引起始位置从0开始，超出范围直接报错。ps索引值为-1指倒数第一个字符。
s = 'wow unbelievible'
print(s[2]) # w
print(s[-1]) # e
3.切片操作
切片位置中括号左边包含，右边不包含；切片位置一定要从左往右。
print(s[1: 6]) # ow un
print(s[-1: -5]) # 不打印，因为索引默认从左往右
print(s[-5: -1]) # vibl
4.修改切片方向、间隔
s = 'wow unbelievible'
print(s[1:5:1]) # ow u 间隔默认为1
print(s[4:10:2]) # ubl
print(s[-1:-5:-1]) # elbi， 末尾-1修改切片方向，中括号左边包含，右边不包含
print(s[:]) # wow unbelievible,没有数字，默认打印全部字符串
print(s[2:]) # w unbelievible,结尾没有数字，默认从索引2开始打印
print(s[:5]) # wow u, 开头没有数字，默认从索引0打印到索引4
print(s[::2]) # wwubleil，打印全部字符，间隔为2
5.统计字符串中总字符的个数
语法结构:len(变量名)，字符个数包含空格
s = 'wow unbelievible'
print(len(s)) # 16
6.移除字符串首位指定字符
语法结构: 字符串.strip（）（括号内可以指定字符）
6.1 括号内无指定字符默认移除首位空格,可以用在获取用户输入时，防止因多敲空格引起输入错误
user_name = input('请输入您的用户名>>>:').strip()
if user_name == 'max':
print('登陆成功')
6.2 括号内指定字符可以在首位移除指定字符
s = '$$$wow unbelievible$$'
s1 = s.strip('$')
print(s1) # wow unbelievible
6.3 lstrip（）和rstrip分别移除左右指定字符
s = '$$$wow unbelievible$$'
s1 = s.lstrip('$')
s2 = s.rstrip('$')
print(s1, s2) # wow unbelievible$$ $$$wow unbelievible
7.切割字符串中指定字符
7.1可以按照字符串中某个元素把字符串切割成几个元素，并形成一个列表
res = 'max|25|soccer|handsome'
print(res.split('|')) # 打印成一个列表
name, age, hobby, appe = res.split('|') # 解压赋值
print(name, age, hobby, appe)
7.2可以指定方向切指定个数
res = 'max|25|soccer|handsome'
print(res.split('|', maxsplit=1)) # ['max', '25|soccer|handsome'],默认从左往右切，切1个
print(res.rsplit('|', maxsplit=2)) # ['max', '25|soccer|handsome'],从右往左切，切2个
8.字符串格式化输出
8.1format用法1：相当于占位符:占位符和元组内元素个数要相同
s = 'my name is {},my age is {}'
print(s.format('max', 25))
8.2format用法2:索引取值并支持反复使用
s = 'my name is {0},my age is {1},我叫{0},我的年龄是{1}'
print(s.format('max', 25))
8.3format用法3:占位符用变量名
s = 'my name is {name},my age is {age},我叫{name},我的年龄是{age}'
print(s.format(name='max',age=25))
8.4获取用户输入然后使用
语法结构： s = f'内容(当中应含有获取用户输入得到的变量名，用大括号括起来)'
username = input('请输入您的用户名>>>:').strip()
age = input('请输入您的年龄>>>:').strip()
s = f'my name is {username},my age is {age},我叫{username},我的年龄是{age}'
print(s)
9.字符串大小写转化
9.1大小写转化:转化成大写：字符串.upper();转化成小写: 字符串.lower()
res = 'woW uNBeLiEvIBle'
print(res.lower())
print(res.upper())
9.2图片验证码：系统生成没有大小统一的验证码，展示给用户看，获取用户输入，然后和系统产生的验证码统一转成大写或小写之后再对比。
code = '8Ja6Cc'
print('展示给用户看的验证码', code)
confirm_code = input('请输入验证码>>>:')
if confirm_code.upper() == code.upper():
print('验证码输入正确')
9.3判断字符串中是否是纯大写或纯小写，判断结果是布尔值
s = 'wow unbelievible'
print(s.islower()) # True
print(s.isupper()) # False
10.判断字符串是否是纯数字(整数）
判断结果是布尔值
s = '564424'
print(s.isdigit()) # True
user_age = input('请输入您的年龄>>>:')
if user_age.isdigit():
user_age = int(user_age)
print('真棒')
else:
print('数字都不会输嘛')
11.替换字符串中指定的字符
可以加1个参数控制从左往右替换的个数
s = 'the most handsome boy in my class is max, max! max!'
print(s.replace('max', 'jason')) # the most handsome boy in my class is jason, jason! jason!
print(s.replace('max', 'jason', 2)) # the most handsome boy in my class is jason, jason! max!
12.字符串的拼接
12.1两个字符串拼接，可以直接用+相连
s1 = 'wow'
s2 = 'unbelievible'
print(s1 + s2) # wowunbelievible
"""
中间也可以加字符串
print(s1 + '!!!' + s2) # wow!!!unbelievible
print(s1 + s2 + '!!!') # wow!!!unbelievible
"""
12.2关键字join可以把指定字符插入列表中的元素，组成一个字符串，是split的反向操作。列表中的元素必须都是字符串.
l1 = ['jason', 'max', 'john']
print('|'.join(l1)) # jason|max|john
l1 = ['jason', 'max', 'john', 123]
print('|'.join(l1)) # 报错
l1 = ['jason', 'max', 'john', '123']
print('|'.join(l1)) # jason|max|john|123
13.统计指定字符出现的个数
语法结构:print(字符串.count('指定字符'))
s1 = 'wow unbelievible'
print(s.count('e'))
14.判断字符串的开头和结尾
语法结构:print('字符串'.startswith('指定字符'))、print('字符串'endswith('指定字符'))。结果是布尔值。
s1 = 'wow unbelievible'
print(s1.startswith('wow')) # True
print(s1.startswith('w')) # True
print(s1.startswith('wow ')) # True
print(s1.endswith('e')) # True
print(s1.endswith(' ')) # True
15.字符串中每个单词的首字母大写
语法结构:print('字符串'.title())
s3 = 'hala mardid hala mardid'
print(s3.title()) # Hala Mardid Hala Mardid
16.第一个单词的首字母大写
语法结构:print('字符串',capitalize())
s3 = 'hala mardid hala mardid'
print(s3.capitalize()) # Hala mardid hala mardid
17.字符串中的字符大小写反转
语法结构:print('字符串'.swapcase())
s3 = 'Hala Mardid Hala Mardid'
print(s3.swapcase()) # hALA mARDID hALA mARDID
18.根据字符查找索引值
语法结构:print(index())或print(find()),只能从左往右查找到第一个指定字符的索引值
s3 = 'hala mardid hala mardid'
print(s3.index('a')) # 1
print(s3.find('a')) # 1
"""
index()和find()区别:当一个字符串中没有要查找的字符时，index()会直接报错，find()会打印-1。
"""
print(s3.index('b')) # 报错
print(s3.find('b')) # -1
字符串.rfind()：查找指定内容在字符串当中最大的索引值：
s = 'hello jason'
print(s.find('o')) # 4
print(s.rfind('o')) # 9
19.字符串join方法：字符串会将自己复制多份，插到join参数中每两个参数中间，首位不插：
s = '2 22'
s1 = s.join('uyghkjh')
print(s1) # u2 22y2 22g2 22h2 22k2 22j2 22h
5.数据类型之列表list
可以存放多个数据类型，用逗号隔开，用中括号括起来，并且将来可能会单独存取其中一些的数据类型。
1.代码实现
name_list = ['jason', 'tony', 'kevin', 'oscar', 'jerry']
2.列表中的元素不仅可以是整型浮点型、字符串，还可以是另一个列表。
list1 = [1, 2, 3, [3.3, 3.4, 3.5]]
3.字典取值需要索引取值，print(变量名[索引值])，索引值从0开始计。
内置方法:
1.索引取值
索引值从0开始，最后一位索引值是负1
l = [1, 2, 3, 4, 5, 6]
print(l[2]) # 3
print(l[-1]) # 6
2.切片操作、间隔数、方向(与字符串一样)
l = [1,2,3,4,5,6,7,8]
print(l[0:4]) # [1, 2, 3, 4]
print(l[-5:-1]) # [4, 5, 6, 7]
print(l[:]) # [1, 2, 3, 4, 5, 6, 7, 8]
print(l[2:]) # [3, 4, 5, 6, 7, 8]
print(l[:4]) # [1, 2, 3, 4]
print(l[1:7:2]) # [2, 4, 6]
print(l[::-1]) # [8, 7, 6, 5, 4, 3, 2, 1] 反向打印列表
"""
面试题：
列表切片操作超出范围不会报错，而是会打印一个空列表：
l = [1,2,3,4,5,6,7,8]
print(l[10:]) # []
"""
3.统计列表中数据值的个数
语法结构:print(len('变量名'))
l = [1, 2, 3, 4, 5, 6, 7, 8]
print(len(l)) # 8
4.数据值修改
通过索引修改，打印直接打印原列表变量名
l = [1, 2, 3, 4, 5, 6, 7, 8]
l[0] = 111
print(l) # [111, 2, 3, 4, 5, 6, 7, 8]
5.列表添加数据值
5.1尾部追加数据值
语法结构：列表变量名.append('任意数据类型')，列表可以支持任意数据类型，所以可以添加任意数据类型,会当做一个元素放入原列表中
l = [1, 2, 3, 4, 5, 6, 7, 8]
l.append(9)
print(l) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
l.append([111, 222, 333])
print(l) # [1, 2, 3, 4, 5, 6, 7, 8, 9, [111, 222, 333]]
5.2 任意位置插入数据值
l = [1, 2, 3, 4, 5, 6, 7, 8]
l.insert(1, 111)
print(l) # [1, 111, 2, 3, 4, 5, 6, 7, 8]
l.insert(2, ['max', 'jason'])
print(l) # [1, 111, ['max', 'jason'], 2, 3, 4, 5, 6, 7, 8]
5.3 扩展列表、合并列表
l1 = [1, 2, 3]
l2 = [4, 5, 6]
print(l1 + l2) # [1, 2, 3, 4, 5, 6]
或l1.extend(l2)
print(l1) # [1, 2, 3, 4, 5, 6]
extend深层原理：
for i in l2:
l1.append(i)
print(l1) # [1, 2, 3, 4, 5, 6]
6.删除列表数据
方式1：
l = [1, 2, 3, 4, 5, 6, 7, 8]
del l[2]
print(l) # [1, 2, 4, 5, 6, 7, 8]
方式2：
l = [1, 2, 3, 4, 5, 6, 7, 8]
l.remove(3)
方式3：
l = [1, 2, 3, 4, 5, 6, 7, 8]
l.pop(2)
print(l) # [1, 2, 4, 5, 6, 7, 8]
pop和remove区别:
pop()默认弹出尾部元素，给该数据值赋值一个变量名该变量名可以用，remove不行
l = [1, 2, 3, 4, 5, 6, 7, 8]
res = l.pop()
print(res) # 8
res = l.remove()
print(res) # 报错
7.排序
默认是升序，降序要加reverse =True
l1 = [45, 23, 63, 68, 12, 6, 78]
l1.sort()
print(l1) # [6, 12, 23, 45, 63, 68, 78]
l1.sort(reverse=True)
print(l1) # [78, 68, 63, 45, 23, 12, 6]
8.统计列表中某个数据值出现的次数
l1 = [45, 23,45, 68, 12, 6, 45]
print(l1.count(45)) # 3
9.颠倒列表顺序
l1 = [45, 23,45, 68, 12, 6, 45]
l1.reverse()
print(l1) # [45, 6, 12, 68, 45, 23, 45]
"""
很多程序土工用户注销功能，其实底层并没有删除用户的数据，而是修改了布尔值
"""
6.数据类型之字典dict
能够非常精确的存储和表达数据值的含义
代码实现:
info_dict = {
'username': 'jason',
'age': 18,
'hobby': 'read',
}
1.字典文字描述
大括号括起来，内部可以存放多个数据，数据的组织形式是K:V键值对，键值对与键值对之间逗号隔开，K是对V的描述性性质的信息(解释说明) 一般都是字符串类型，V是真正的数据值 可以是任意数据类型
2.按K取值
字典只能按K取值 因为字典是无序的 没有索引的概念
info_dict['username']
相关操作：
1.类型转换:
字典的转换一般不使用关键字，自己手动转
2.按K取值:K不存在时会报错，不推荐使用
user_dict = {
'username': 'max',
'password': 123,
'hobby': ['read', 'soccer', 'run'],
'base': 'Shanghai'
}
print(user_dict['base']) # Shanghai
print(user_dict['age']) # 报错
3.按get取值：推荐，K不存在时会返回None，不会报错
user_dict = {
'username': 'max',
'password': 123,
'hobby': ['read', 'soccer', 'run'],
'base': 'Shanghai'
}
print(user_dict.get('username')) # max
print(user_dict.get('age')) # None
4.按get取值用法2：get后跟一个变量名和一个数据值时，如果变量名是字典中的K，则返回K对应的V，如果变量值不是字典中的K，则返回后面的数据值
user_dict = {
'username': 'max',
'password': 123,
'hobby': ['read', 'soccer', 'run'],
'base': 'Shanghai'
}
print(user_dict.get('username', '哈哈哈')) # max
print(user_dict.get('age', '哈哈哈')) # 哈哈哈
5.修改数据值：如果K存在字典可以通过按K修改对应的V，修改前后内存地址未变说明字典是可变类型。
print(user_dict, id(user_dict)) # {'username': 'max', 'password': 123, 'hobby': ['read', 'soccer', 'run'], 'base': 'Shanghai'} 2271380003520
user_dict['username'] = 'jason'
print(user_dict, id(user_dict)) # {'username': 'jason', 'password': 123, 'hobby': ['read', 'soccer', 'run'], 'base': 'Shanghai'} 2271380003520
6.新增键值对：若K不存在，则是新增键值对
user_dict['age'] = 25 # {'username': 'max', 'password': 123, 'hobby': ['read', 'soccer', 'run'], 'base': 'Shanghai', 'age': 25}
print(user_dict)
7.删除数据之del：变量名后的中括号写K，KV键值对会一并删除
del user_dict['base']
print(user_dict) # {'username': 'max', 'password': 123, 'hobby': ['read', 'soccer', 'run']}
8.删除数据值pop，pop后面的括号内写K，给该变量名命名打印的结果是该K对应的V
res = user_dict.pop('hobby')
print(user_dict, res) # {'username': 'max', 'password': 123, 'base': 'Shanghai'} ['read', 'soccer', 'run']
9.统计键值对的个数
print(len(user_dict)) # 4
10.字典三剑客：keys是获取所有键，values是获取所有的值，items是获取所有的键值对，每个键值对组成一个元祖，若干个元祖组成一个列表。
print(user_dict.keys()) # dict_keys(['username', 'password', 'hobby', 'base'])
print(user_dict.values()) # dict_values(['max', 123, ['read', 'soccer', 'run'], 'Shanghai'])
print((user_dict.items())) # dict_items([('username', 'max'), ('password', 123), ('hobby', ['read', 'soccer', 'run']), ('base', 'Shanghai')])
for k, v in user_dict.items():
print(k, v) # 结果：k是左右的键，v是所有的值
11.关键字fromkeys：
1.如果fromkeys括号内有两个参数：dict.fromkeys()括号内跟两个列表，第一个列表是键的集合，第二个列表是值，是所有键的值（每个键的值相同。如果值的集合是空集合，通过fromkeys组成一个字典之后，通过索引给值列表增加数据值，所有的值会变成一个集合。当第二个公共值是可变类型的时候 一定要注意 通过任何一个键修改都会影响所有
res = dict.fromkeys(['name' ,'age', 'base'], ['max', 25, 'shanghai'])
print(res) # {'name': ['max', 25, 'shanghai'], 'age': ['max', 25, 'shanghai'], 'base': ['max', 25, 'shanghai']}
res = dict.fromkeys(['name', 'age', 'hobby'], [])
print(res) # {'name': [], 'age': [], 'hobby': []}
res['name'].append('max')
res['age'].append(25)
res['hobby'].append('soccer')
print(res) # {'name': ['max', 25, 'soccer'], 'age': ['max', 25, 'soccer'], 'hobby': ['max', 25, 'soccer']}
2.如果fromkeys中只有一个参数，代表第二个参数也就是所有键的值为空：
l1 = [1,2,3]
print(dict.fromkeys(l1)) # {1: None, 2: None, 3: None}
"""
list()括号内放置一个字典，执行的结果就是字典的键组成的列表：
print(list({'name':'max','age':26})) # ['name', 'age']
面试题：
a = [1,2,3,1,2,4,6]
b = {}
b = list(b.fromkeys(a))
字典.fromkeys(a)相当于是组成了一个所有值都为None的字典，并且字典的键会去重(顺序不一定按这个因为字典会去重)：{1:None,2:None,3:None,4:None,6:None}
list(字典)是将所有字典的键组合成一个列表，所以该题目的目的是给列表a去重(但是不保持原来的顺序)
"""
12.setdefault关键字：键存在时则不修改值，键不存在时则新增键值对
user_dict = {
'username': 'max',
'password': 123,
'hobby': ['read', 'soccer', 'run'],
}
user_dict.setdefault('username', 'jason')
print(user_dict) # {'username': 'max', 'password': 123, 'hobby': ['read', 'soccer', 'run']}
user_dict.setdefault('base', 'shanghai')
print(user_dict) # {'username': 'max', 'password': 123, 'hobby': ['read', 'soccer', 'run'], 'base': 'shanghai'}
13.update关键字:键存在则修改值，键不存在则新增键值对
d = {'name': 'max', 'age': 25, 'hobby':'soccer'}
d.update({'age': 26, 'job':'programmer', 'hobby': 'read'})
print(d) # {'name': 'max', 'age': 26, 'hobby': 'read', 'job': 'programmer'}
7.基本数据类型之布尔值bool
1.用来判断事物的对错，是否可行，用于流程控制中
2.只有两种状态：
True：对的、真的、可行的
False：错的、加的、不可行的
3.python中所有的数据都自带布尔值
布尔值为False的数据: 0 None ''(空字符串) [](空列表) {}(空字典)
除了上面的数据布尔值都是True
4.存储布尔值的变量名一般都是以is开头
is_delete = True
is_alive = True
8.数据类型之元组tuple
1.也称为'不可变'的列表：
元组内索引绑定的内存地址不能修改。
2.小括号括起来，内部存放多个数据值，数据值与数据值之间用逗号隔开，数据值可以是任意数据类型。
3.代码实现
t1 = (10, 11.11, 'max')
4.元组和列表对比
4.1 元组和列表都可以通过索引取值，列表可以通过索引把其中某个元素赋予新的数据值，但元组不行。
# list = [11, 22, 33]
# print(list[0])
# list[0] = 888
# print(list[0]) 结果： [888, 22, 33]
# t1 = (11, 22, 33)
# print(t1[0])
# t1[0] = 666
# print(t1) 结果：报错
4.2 元组'不可变'，不能通过索引来改变内部的元素，但列表增加一个元素后内存地址并未改变，相当于元组中的元素没有改变。
# t1 = (11, 22, [111, 222])
# t1[2][1] = 666
# print(t1) 结果：(11, 22, [111, 666])
5.当元组内部只有一个数据值：数据类型是它本身的数据类型，加一个逗号之后，数据类型是元祖
# t1 = (11)
# t2 = (11,)
# print(type(t1)) #<class 'int'>
# print(type(t2)) #<class 'tuple'>
# t1 = (12.12)
# t2 = (12.12,)
# print(type(t1)) #<class 'float'>
# print(type(t2)) #<class 'tuple'>
# t1 = ('max')
# t2 = ('max',)
# print(type(t1)) #<class 'str'>
# print(type(t2)) #<class 'tuple'>\
"""
建议：如果以后可以存储多个数据值的数据类型中只有一个数据值时，建议数据值后面加上逗号
"""
相关操作:
1.类型转化：
tuple(),支持for循环的数据类型（字符串、列表、字典、元组、集合）都可以转化成元组。
2.索引取值
t1 = (11, 22, 33, 44, 55, 66)
print(t1[0]) # 11
3.切片操作
print(t1[1:4]) # (22, 33, 44)
4.间隔、方向
print(t1[1:6:2]) # (22, 44, 66)
print(t1[-1:-5:-1]) # (66, 55, 44, 33)
5.统计元组内数据值的个数
print(len(t1)) # 6
6.统计元组内某个数据值出现的次数
print(t1.count(22)) # 1
7.统计元组内指定数据值的索引值
print(t1.index(33)) # 2
8.元组内如果只有一个数据值那么逗号不能少
t1 = (11,)
9.元组内索引绑定的内存地址不能被修改,但如果内部有列表、字典这种可变类型，字典、列表发生变化但内存地址不变，则元组的内存地址也未变。
10.元组不能新增或删除数据
11.元组*n(整形)相当于把这个元组重写了n次：
t1 = (1, 2, 3, 4)
print(t1*3) # (1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4)
12.元组内不能套列表、字典：
l = [1,2,3,'jason']
print(set(l)) # {1, 2, 3, 'jason'}
l = [1,2,3,[1,2]]
print(set(l)) # 报错
l = [1,2,3,{'name':'max'}]
print(set(l)) # 报错
9.基本数据类型之集合set
1.集合只能用于去重和关系运算(未讲，暂且忽略)。
2.集合内数据只能是不可变类型(未讲，暂且忽略)。
3.大括号括起来，内部存放多个数据值，数据值之间用逗号隔开，数据值不是K:V键值对。
4.代码实现：
s1 = {1, 2, 3, 4}
5.空集合和空字典：
{} 默认是字典
set() 默认是集合
相关操作：
1.类型转化
set()
集合内数据必须是不可变类型（整形、浮点型、字符串、元组）
集合内部数据也是无序的，没有索引的概念（同字典）
2.去重；集合去重无法保留原先的排列顺序
l1 = [11, 22, 33, 22, 11, 22, 33, 22, 11, 22, 33, 22]
s1 = set(l1)
l = list(s1)
print(l) # [33, 11, 22]
3.关系运算:
f1 = {'jason', 'tony', 'jerry', 'oscar'} # 用户1的好友列表
f2 = {'jack', 'jason', 'tom', 'tony'} # 用户2的好友列表
1.求两个人的共同好友(交集)
print(f1 & f2) # {'jason', 'tony'}
2.求用户1独有的好友(真子集)
print(f1 - f2) # {'oscar', 'jerry'}
3.求两个人所有的好友(并集)
print(f1 | f2) # {'jack', 'tony', 'tom', 'jason', 'jerry', 'oscar'}
4.求两个人各自独有的好友(真子集的并集)
print(f1 ^ f2) # {'oscar', 'jerry', 'jack', 'tom'}
10.可变类型和不可变类型
# s1 = '$$jason$$'
# l1 = [11, 22, 33]
# s1.strip('$')
# print(s1) # $$jason$$
'''字符串在调用内置方法之后并不会修改自己 而是产生了一个新的结果
如何查看调用方法之后有没有新的结果 可以在调用该方法的代码左侧添加变量名和赋值符号
res = s1.strip('$')
'''
# ret = l1.append(44)
# print(l1) # [11, 22, 33, 44]
# print(ret) # None
'''列表在调用内置方法之后修改的就是自身 并没有产生一个新的结果'''
# 可变类型:值改变 内存地址不变
# l1 = [11, 22, 33]
# print(l1)
# print(id(l1))
# l1.append(44)
# print(l1)
# print(id(l1))
# 不可变类型:值改变 内存地址肯定变
res = '$$hello world$$'
print(res)
print(id(res))
res.strip('$')
print(res)
print(id(res))
练习：
'''
2.基于字符串充当数据库完成用户登录(基础练习)
data_source = 'jason|123' # 一个用户数据
获取用户用户名和密码 将上述数据拆分校验用户信息是否正确
'''
# data_source = 'jason|123'
# name, pwd = data_source.split('|')
# user_name = input('请输入您的用户名>>>:').strip()
# user_pwd = input('请输入您的密码>>>:').strip()
# if user_name == name and user_pwd == pwd:
# print('登陆成功')
# else:
# print('用户名或密码错误')
'''
3.基于列表充当数据库完成用户登录(拔高练习) # 多个用户数据
data_source = ['jason|123', 'kevin|321','oscar|222']
'''
# 方法1：把获取到的用户数据凭借成字符串，用到join关键字
# data_source = ['jason|123', 'kevin|321','oscar|222']
# user_name = input('请输入您的用户名>>>:').strip()
# user_pwd = input('请输入您的密码>>>:').strip()
# user_data = '|'.join([user_name, user_pwd])
# if user_data in data_source:
# print('登陆成功')
# else:
# print('登陆失败')
# 方法2：把获取到的用户数据凭借成字符串，用到format格式化输出
data_source = ['jason|123', 'kevin|321','oscar|222']
user_name = input('请输入您的用户名>>>:').strip()
user_pwd = input('请输入您的密码>>>:').strip()
user_data = f'{user_name}|{user_pwd}'
if user_data in data_source:
print('登陆成功')
else:
print('用户名或密码错误')
# 方法3：把数据库里的列表拿出来对比:用到for循环
data_source = ['jason|123', 'kevin|321','oscar|222']
user_name = input('请输入您的用户名>>>:').strip()
user_pwd = input('请输入您的密码>>>:').strip()
for data in data_source: # data: 'jason|123' 'kevin|321' 'oscar|222'
name, pwd = data.split('|')
if user_name == name and user_pwd == pwd:
print('登陆成功')
else:
print('用户名或密码错误')
'''
4.利用列表编写一个员工姓名管理系统
输入1执行添加用户名功能
输入2执行查看所有用户名功能
输入3执行删除指定用户名功能
分析 用户输入的不同 可以执行不同的代码
ps: 思考如何让程序循环起来并且可以根据不同指令执行不同操作
提示: 循环结构 + 分支结构
拔高: 是否可以换成字典或者数据的嵌套使用完成更加完善的员工管理而不是简简单单的一个用户名(能写就写不会没有关系)
data_list = []
while True:
print('''
1执行添加用户名功能
2执行查看所有用户名功能
3执行删除指定用户名功能
''')
choice = input('请输入您的选项>>>:').strip()
if choice == '1':
user_name = input('请输入您要添加的用户名>>>:')
if user_name in data_list:
print('用户名已注册')
else:
data_list.append(user_name)
print(f'用户名{user_name}已添加完毕')
elif choice == '2':
for old_data in data_list:
print(f"""
---------user info----------
{old_data}
----------------------------
""")
elif choice == '3':
del_name = input('请输入您要删除的')
if del_name in data_list:
data_list.remove(del_name)
print(f'用户名{del_name}删除完毕')
else:
print(f'用户名{del_name}未注册')
else:
print('请输入正确的任务编号')
拔高1:只有密码（字典）
user_dict = {}
while True:
print("""
1执行添加用户名功能
2执行查看所有用户名功能
3执行删除指定用户名功能
""")
choice = input('请输入您的选项>>>:').strip()
if choice == '1':
user_name = input('请输入您要注册的用户名>>>:').strip()
user_pwd = input('请输入您的密码>>>:').strip()
if user_name in user_dict:
print('该用户名已添加')
else:
user_dict[user_name] = user_pwd
print(f'用户{user_name}已添加')
print(user_dict)
elif choice == '2':
print(user_dict.keys())
elif choice == '3':
del_name = input('请输入您要删除的用户名>>>:')
del user_dict[del_name]
print(f'用户{del_name}已成功删除')
else:
print('请按照提示输入正确选项')
拔高2：信息含有年龄，职位，电话（字典的V是列表）
user_dict = {}
while True:
print("""
1执行添加用户名功能
2执行查看所有用户名功能
3执行删除指定用户名功能
""")
choice = input('请输入您的选项>>>:').strip()
if choice == '1':
user_name = input('请输入您要注册的用户名>>>:').strip()
if user_name in user_dict:
print('该用户名已注册')
continue
else:
user_gender = input('请输入您的性别>>>:').strip()
user_num = input('请输入您的号码>>>:').strip()
if user_name == 'kiki':
user_job = '高级管理员'
elif user_name == 'kimi':
user_job = '超级管理员'
elif user_name == 'tom':
user_job = '普通管理员'
else:
user_job = '普通员工'
user_list = [user_gender, user_num, user_job]
user_dict[user_name] = user_list
print(f'用户名{user_name}注册成功')
elif choice == '2':
# print(user_dict) # {'kiki': ['female', '123', '高级管理员'], 'tom': ['male', '456', '普通管理员']}
for name in user_dict:
gender, age, job = user_dict.get(name)
print(f"""
---------------------------
姓名:{name}
性别:{gender}
年龄:{age}
职位:{job}
---------------------------
""")
elif choice == '3':
del_user = input('请输入您要删除的用户名>>>:')
if del_user not in user_dict:
print('该用户名未注册>>>:')
else:
del user_dict[del_user]
print(f'用户{del_user}删除成功')
5.去重下列列表并保留数据值原来的顺序
eg: [1,2,3,2,1] 去重之后 [1,2,3]
l1 = [2,3,2,1,2,3,2,3,4,3,4,3,2,3,5,6,5]
l1 = [2,3,2,1,2,3,2,3,4,3,4,3,2,3,5,6,5]
l2 = []
for count in l1:
if count in l2:
continue
else:
l2.append(count)
print(l2)
6.有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
linuxs={'kermit','tony','gangdan'}
1. 求出即报名python又报名linux课程的学员名字集合
2. 求出所有报名的学生名字集合
3. 求出只报名python课程的学员名字
4. 求出没有同时这两门课程的学员名字集合
pythons = {'jason', 'oscar', 'kevin', 'ricky', 'gangdan', 'biubiu'}
linuxs = {'kermit', 'tony', 'gangdan'}
# 1. 求出即报名python又报名linux课程的学员名字集合
print(pythons & linuxs)
# 2. 求出所有报名的学生名字集合
print(pythons | linuxs)
# 3. 求出只报名python课程的学员名字
print(pythons - linuxs)
# 4. 求出没有同时这两门课程的学员名字集合
print(pythons ^ linuxs)
7.统计列表中每个数据值出现的次数并组织成字典战士
eg: l1 = ['jason','jason','kevin','oscar']
结果:{'jason':2,'kevin':1,'oscar':1}
真实数据
l1 = ['jason','jason','kevin','oscar','kevin','tony','kevin']
dict = {}
l1 = ['jason','jason','kevin','oscar','kevin','tony','kevin']
for name in l1:
if name not in dict:
num = l1.count(name)
dict[name] = num
print(dict)
