基本数据类型的内置方法与可变不可变类型

一、基本数据类型的内置方法

1.1 整数和浮点数

1、整数
# 整数的转换
    age = "18"
    print = int(age)
# 非整数型的是转换不了整数，比如
	height = 1.8
    print = int(height)  # 这个是错误的，带了小数点，应该转换成浮点型
    name = "Ame"
    print = int(name)  # 这个是错误的，因为字符串是英文字母组成的
	print(int(11.11))  # 11
    print(int("11.11"))  #报错 因为里面是字符串型的浮点型 
2、浮点型
# 浮点型的装换
	height = 180.1
    print(float(180.1))  # 180.1
    print(float("180.1"))  # 180.1
    print(float(180))  # 180.0
    print(int(11.11))  # 11

1.2 字符串

1、字符串的查找(索引)   索引是从0开始的
	name = "ameameame"
    print(name[0])  # a
    print(name[-1])  # e
2、字符串的查找(切片)
	name = "ameameame"
    print(name[0:6:1])  # ameame 1 乃是步长的意思
    print(name[0:6:2])  # aem	2 乃是步长的意思
    print(name[-1:-6:-1])  #emaem 	3 因为查找默认是从左到右，所以得加-1来从右到左的查找
3、字符串的长度
	name = "ameameame"
	print(len(name))  # len是能弄清楚字符串的长度  name长度为9  提示 空格也算字符
4、字符串的.sprit()用法
	# .strip是去除字符串指定首尾的字符，默认不指定的时候则是去除首尾空格
    name = "      ameameame    "
    print(name.strip())  # ameameame 去除了首尾空格
    name = "%%ameameame%%"
    print(name.strip("%"))  # ameameame 去除了首尾%
    name = "%%ameame%a%m%eame%%"
    print(name.strip("%"))  # ameame%a%m%eame  只能去首尾，中间的不能去除
    # 如何才能去除左边的保留右边的(.lstrip)
    name = "%%ameameame%%"
    print(name.lstrip("%"))  # ameameame%%
    # 如何才能去除右边的保留左边的(.rstrip)
    name = "%%ameameame%%"
    print(name.rstrip("%"))  # %%ameameame
5、字符串的判断在不在字符串里面(in      not in)
	name = "ameameame"
    print("a" in name)  # True
    print("q" not in name)  # False
6、字符串的.split()用法
	str = "1!2!3!4!5!6!7!8!9"
    list = str.split("!")
    print(list)  # ['1', '2', '3', '4', '5', '6', '7', '8', '9']
    # 因此可以看出字符串转换成了列表，切割的"！"也不会被保留，所以切记，以后碰到字符串转列表就可以用.split用法。
    list1 = str.split("!",maxsplit=2) # print(list)  # ['1', '2', '3!4!5!6!7!8!9']
    # 默认.split是从左到右切割
    list2 = str.rsplit("!",maxsplit=2)  # ['1!2!3!4!5!6!7', '8', '9']
7、字符串的循环方法
	name = "ameameame"
	for i in name
    	print(i)  # 依次获取字符串中单个单个的字符
        
8、把字符串全部变成大写或者小写
	name = "amEaMeame"
    # 全部转成大写
    print(name.upper())  # "AMEAMEAME"
    # 全部转成小写
    print(name.lower())  # "ameameame"
    # 应用于图片验证码
    
9、字符串开头结尾
    res = 'Ame Yuki lalala'
    # 判断字符串是否以Ame开头
    print(res.startswith('Ame'))  # True
    # 判断字符串是否以lalala结尾
    print(res.endswith('lalala'))  # True
 
10、格式化输出 format
	2.1
    res = "班上的时常达{}年的练习生{}, 他的爱好就是{}," \
          "并且在他{}岁的时候， 编出了鸡你太美舞蹈".format(2.5, "小明", "唱 跳 rap 篮球", 60)
    print(res)
    班上的时常达2.5年的练习生小明, 他的爱好就是唱 跳 rap 篮球,并且在他60岁的时候， 编出了鸡你太美舞蹈
    

    res = "班上的时常达{0}{0}年的练习生{1}{1}, 他的爱好就是{2}{2}," \
    	  "并且在他{3}{3}岁的时候， 编出了鸡你太美舞蹈".format(2.5, "小明", "唱 跳 rap 篮球", 60)
    print(res)
    班上的时常达2.52.5年的练习生小明小明, 他的爱好就是唱 跳 rap 篮球唱 跳 rap 篮球,并且在他6060岁的时候， 编出了鸡你太美舞蹈

	2.2 
	res = "班上的时常达{year}年的练习生{name}, 他的爱好就是{hobby},".format(name="小明", year=2.5, hobby="篮球")
	print(res)
    班上的时常达2.5年的练习生小明, 他的爱好就是篮球,	
    
11、统计字符串中字符出现的次数
	name = "ameameame"
	print(name.count("a"))  # 3 统计"a"出现的次数
    print(name.count("a", 0, 4))  # 2 在索引0-3 统计"a"出现的次数
    
12、把字符串首字母都变成大写(可以用于标题)
	res = 'my name is ame nis IO KSn kls  '
	print(res.title())  # 将所有英文单词首字母大写   My Name Is Ame Nis Io Ksn Kls 
	print(res.capitalize())  # 首字母大写 后面统一变小写    My name is ame nis io ksn kls
    
13、判断字符串是否为纯数字
	guess_age = input('请输入您的年龄>>>:')
    if guess_age.isdigit():
    	将字符串的数字转为整型的数字
        guess_age = int(guess_age)  
    else:
        print('请输入纯数字')
        
 14、文本功能 替换关键字
	res = "my name is Ame Ame Ame"
    res.replace('Ame', 'yuki')  # my name is yuki yuki yuki
    res.
 15、列表转换成字符串 .join
	list = ["1", "2", "3", "4", "5", "6"]
	print(",".join(list))  # 1,2,3,4,5,6
    # 切记 只能转换列表是字符串你类型

1.3 列表

1、列表的查找(索引)
	list = [1, 2, 3, 4, 5, 6]
    list[0]  # 1
    list[-1]  # 6
2、列表的查找(切片)
	list = [1, 2, 3, 4, 5, 6]
    list[0:5]  # 默认步长为一  [1, 2, 3, 4, 5] 
    list[0:5:2]  # [1, 3, 5]
3、列表中元素的个数 len
	list = [1, 2, 3, 4, 5, 6]
    len(list)  # 6
4、 列表的增删改查
	list = ["ame", "yuki", "vlicecream"]
    list[0] = "yuki"
5、列表增加元素 append 尾部追加
	list = ["ame", "yuki", "vlicecream"]
    list.append["monica"]  # list =  list = list = ["ame", "yuki", "vlicecream", "monica"]
6、列表删除元素 del remove pop
	# del
	list = ["ame", "yuki", "vlicecream"]
    del list[0]  # list = ["yuki", "vlicecream"]
    # remove  指名道姓的删除
    list = ["ame", "yuki", "vlicecream"]
    list.remove("ame")  # list = ["yuki", "vlicecream"]
    # pop
    list = ["ame", "yuki", "vlicecream"]
    list.pop()  # 如果没有加索引，那么是默认尾部弹出 也就是删除尾部，但是这个传出来的值是尾部的值   list = ["ame", "yuki"]
   
7、列表插入元素
	list = ["ame", "yuki", "vlicecream"]
    list.insert(0, "monica")  #list = ["monica", "ame", "yuki", "vlicecream"]
    
8、拓展列表
	list = ["ame", "yuki", "vlicecream"]
    list1 = ["am", "yuk", "vlicecrea"]
    list.extend(list1)
    print(list)  # ['ame', 'yuki', 'vlicecream', 'am', 'yuk', 'vlicecrea']
    
9、统计列表元素出现的个数
    list = ["ame", "yuki", "vlicecream"]
    print(list.count("yuki"))  # 1 统计列表中某个元素出现的次数

10、清理列表
    list.clear()  # 清空列表
    print(name_list)  # list = []

11、列表的升序和降序
	l2 = [11,88,22,44,33,77,66,55]
    l2.sort()  # 排序  默认是升序
    print(l2)  # [11, 22, 33, 44, 55, 66, 77, 88]
    l2.sort(reverse=True)  # reverse=True 降序
    print(l2)  # [88, 77, 66, 55, 44, 33, 22, 11]

    l2.reverse()  # 倒序
    print(l2)

1.4 字典

1. 字典的查找(key)
    dirt = {"name": "Ame",
            "age": 18,
            "hobby": "唱跳Rap篮球"}
    print(dirt["name"])  # Ame
    # 输入不存在的key 会报错
2. 字典keys:Value的个数(len)
    dirt = {"name": "Ame",
            "age": 18,
            "hobby": "唱跳Rap篮球"}
    print(len(dirt))  # 3

3.字典的增改
    dirt = {"name": "Ame",
            "age": 18,
            "hobby": "唱跳Rap篮球"}
    dirt["name"] = "yuki"
    print(dirt)  # {'name': 'yuki', 'age': 18, 'hobby': '唱跳Rap篮球'}
    dirt["id_card"] = 123456789
    print(dirt)  # {'name': 'yuki', 'age': 18, 'hobby': '唱跳Rap篮球', 'id_card': 123456789}

4. 字典的成员运算 in      not in
    dirt = {"name": "Ame",
            "age": 18,
            "hobby": "唱跳Rap篮球"}
    print("name" in dirt)  # True
    print("hobby" not in dirt)  # False

5. 字典的删除(del   pop)
	# del
	dirt = {"name": "Ame",
        "age": 18,
        "hobby": "唱跳Rap篮球"}
    del dirt["name"]
    print(dirt)  # {'age': 18, 'hobby': '唱跳Rap篮球'}
    # pop
    dirt = {"name": "Ame",
        "age": 18,
        "hobby": "唱跳Rap篮球"}
    dirt.pop("name")
    print(dirt)  # pop 则是指定key就去弹出，如果不指定 则默认尾部弹出
    
6. 字典的keys values items
	# keys 显示出所有的key
    dirt = {"name": "Ame",
            "age": 18,
            "hobby": "唱跳Rap篮球"}  
    print(dirt.keys())  # dict_keys(['name', 'age', 'hobby'])
    # values 显示出所有的value
    dirt = {"name": "Ame",
        "age": 18,
        "hobby": "唱跳Rap篮球"}
	print(dirt.values())  # dict_values(['Ame', 18, '唱跳Rap篮球'])
    # items 将items()的结果可以直接看成是列表[]套小列表()
    dirt = {"name": "Ame",
            "age": 18,
            "hobby": "唱跳Rap篮球"}
    print(dirt.items())  # dict_items([('name', 'Ame'), ('age', 18), ('hobby', '唱跳Rap篮球')])
    for k, v in dirt.items():  # 解压赋值 结合 for循环
        print(k, v)  # name Ame   age 18   hobby 唱跳Rap篮球
        
7.字典的循环
    dirt = {"name": "Ame",
            "age": 18,
            "hobby": "唱跳Rap篮球"}
    for i in dirt:
        print(i)  # name  age   hobby
  
8.字典的推荐使用查找方法(get)
	dirt = {"name": "Ame",
        "age": 18,
        "hobby": "唱跳Rap篮球"}
	print(dirt.get("name"))  # Ame
    dirt = {"name": "Ame",
        "age": 18,
        "hobby": "唱跳Rap篮球"}
    print(dirt.get("id card"))  # None
    print(dirt.get("id card", 123456))  # 123456
    dirt.get("name", "yuki")  # Ame
    print(dirt)  # {'name': 'Ame', 'age': 18, 'hobby': '唱跳Rap篮球'}
    # get 假如输入没有的key是不会报错的，会返回None ，所以推荐用get
    
9. 字典的创建方法
	I   dirt = {'name': 'Ame', 'age': 18, 'hobby': '唱跳Rap篮球'}
    II  diet = {key1:value1, key2:value2}
    III list = [
        ['username','jason'],
        ['password',123],
        ['hobby',['read','run']]
        ]
        dirt = {}
        for k, v in list:
            dirt[k] = v
        print(dirt)
        # 列表转字典 方法，一定要注意
        
 10. 字典的清空(clear)
	dirt = {'name': 'Ame', 'age': 18, 'hobby': '唱跳Rap篮球'}
    dirt.clear()
    print(dirt)  # {}
    
11. 快速生成字典(fromkeys)
	dict.fromkeys()  # 快速先生成一个字典
    list = ['username','pwd','hobby']
    res = dict.fromkeys(l,None)
	print(res)
    
12. 字典删除键值对(popitem)
	dirt = {'name': 'Ame', 'age': 18, 'hobby': '唱跳Rap篮球'}
    dirt.popitem()
    print(dirt)  # 字典弹出键值对 尾部弹出
    
13. 字典的修改(setdefault, update)
	# setdefault
	dict.setdefault()  重点
    dd = {'name':'jason','pwd':123}
    dd.setdefault('age',18)  # 键不存在 则新建
    res = dd.setdefault('name','egonSBSBSB')  # 键存在不修改 而是获取到键对应的值
    print(dd,res)  # {'name': 'jason', 'pwd': 123, 'age': 18} jason
	# update
    dict.update()
    dd = {'name':'jason','pwd':123}
    dd.update({'age':18})  # 键不存在 则新建
    dd.update({'name':'EGONDSB'})  # 键存在则修改
    print(dd)
    # 还不如使用下列方式
    dd['age'] = 18
    dd['name'] = 'jason'

1.5 元组

1. 什么是元组
	小括号括起来，里面可以装N多元素的，以逗号隔开，元素可以是任意类型，但是元组是不可变类型，要注意元组只有一个元素时，一定要有逗号，所以以后凡是容器类型，只有一个元素时都不能省略逗号
2. 按索引取值
	tup = (1, 2, 3, 4, 5)
    print(tup[0])  # 1
    print(tup[-1])  # 5
3.	"""
	笔试题
    元组内元素的内存地址不能修改
    但是如果元素是可变类型 那么元素值可以改
	"""
4. 切片
	跟列表一致
   
5. 长度(len)
	跟列表一致
    
6. 成员运算(in   not in)
	跟列表一致
    
7. 循环
	tup = (1, 2, 3, 4, 5)
    for i in tup
    	print(i)

1.6 集合

1.什么是集合
	大括号括起来 内部可以存放多个元素
	元素与元素之间逗号隔开  元素只能是不可变类型(整型 浮点型 字符串 元组)
    
2.集合的应用场景
	只有两种情况才会考虑使用集合
        1.关系运算
            两个群体之间判断 交叉并集
                共同好友 共同关注 共同点赞...
        2.去重操作
            去除重复的元素
            
3. 集合的定义
	# 因为跟字典很像，所以定义空{}的时候 默认是空字典 所以需要加set来声明这是集合
    
4. 集合的去重操作
	# 去重不保留顺序
	l = [11,22,33,22,22,33,11,22,55,66,66,77,77]
    set = set()
    for i in l:
        if i not in set:
            set.add(i)
    print(set)
	
    
    # 去重保留顺序
	l = [11,22,33,22,22,33,11,22,55,66,66,77,77]
    new_l = []
    for i in l:
        if i not in new_l:
            new_l.append(i)
    print(new_l)

5. 关系运算
	f1 = {'jason','egon','kevin','tony'}
	f2 = {'jason','jack','oscar','kevin'}
I 共同好友
	f1 & f2
II f1独有的好友
	f1 - f2
III f2独有的好友
	f2 - f1
IV 所有的好友
	f1 | f2
V  各自的好友 不包括共同好友
	f1 ^ f2
6. 父集 子集
"""
父级:A包含B 那么A就是B的父级
子级:A包含B 那么B就是A的子级
"""
s1 = {1,2,3,4,5}
s2 = {1,2,3}
print(s1 > s2)  # True
print(s1 < s2)  # False

二、可变类型与不可变类型

1.1 可变类型

"""
可变类型
    值改变 内存地址不变
"""
# 可变类型
l1 = [11,22]
print(id(l1))  # 2133952624128
l1.append(666)
print(id(l1))  # 2133952624128

1.2 不可变类型

"""
不可变类型
    值改变 内存地址一定变
"""
# 不可变类型
    a = 1
    print(id(a))  
    a = 2
    print(id(a))