基本数据类型的内置方法汇总

数据类型的内置方法

# 不同的数据类型有不同的功能
视频文件：快进，暂停，后退...
音频：快进，后退，暂停
表格：图形化，公式计算...

1. int() : 将纯整数数字字符串转换为整型类型，若包含其他非整型字符，会报错
	eg：
    	print(int('123.123'))    # 报错 invalid literal for int() with base 10: '123.123'
		print(int('helloworld')) # 报错
		print(int('110'), type(int('110')))  # 110   
	实际应用：将用户输入的字符串转为整型
        age = input('')
        age = int(age)
	'''方法的表现形式：方法名()'''

# 进制之间的转换
    print(bin(13))  # 十进制转二进制
    print(oct(13))  # 十进制转八进制
    print(hex(13))  # 十进制转十六进制
    # 执行结果：
        0b1101  二进制13
        0o15	八进制13
        0xd		十六进制13


# 记忆：0b开头的代表二进制，0o开头的代表八进制， 0x开头的代表十六进制
    print(int('0b1101', 2))  # 二进制转十进制
    print(int('0o15', 8))	 # 八进制转十进制
    print(int('0xd', 16))	 # 十六进制转十进制

2. float() : 将纯浮点数字符串转为浮点数类型
    eg：
    	print(float('11.12'), type(float('11.12')))  # 11.12 

3. str() : 可以将其他任意类型转为字符串类型
    eg：
        print(str(123))
        print(str(11.12))
        print(str([1, 2, 3, 4]))
        print(str({'username': 'ly', 'age': 18}))
        print(str((1, 2, 3)))
        print(str({1, 2, 3}))
        print(str(True))


4. 字符串相关内置方法：（必会）
    s = 'helloworldhelloworldadasdsadsadhelloworldhelloworldhelloworld'
    4.1 支持索引取值
        print(s[0])  # h  从头开始第一个字符，索引从0开始
        print(s[4])  # o  从头开始第5个字符
        print(s[-1])  # d  从后往前第一个字符，负号表示倒数
        print(s[-4])  # o  从后往前第四个字符

	4.2 支持切片操作
        s[1:4]  # 顾头不顾尾  ell
        s[1:9:3]  # 顾头不顾尾, 第三个参数代表步长  eor

	4.3 计算字符串长度
		len(s)

    4.4 strip(): 移除字符串首尾指定的字符(默认移除空格)
        ps：若括号内不指定字符，默认移除空格，若指定字符，则移除指定字符。
        
        string = '   hello     world    '
        string.strip()  # 只去除首尾空格，中间的不管， 默认就是去除的空格
        
        string = '@@@hello     world@@@'
        string.strip('@')  # 只去除首尾@符号，中间的不管
        string.lstrip('@')  # 只去除首部@符号，中间的和尾部的不管
        string.rstrip('@')  # 只去除尾部@符号，中间的和首部的不管

        实例：
        username = input('请输入用户名：')
        username = username.strip()
        if username == 'mark':
            print('ok')
        else:
            print('error')

	4.5 split(): 切分字符串
        ps：若括号内未指定字符，则默认按空格切分，若指定，则按指定字符切分。
        
        source_data = 'mark|18|male'
        print(source_data.split('|'))  # ['mark', '18', 'male']  重点
        print(source_data.split('|', maxsplit=1)) # ['mark', '18|male'] ，maxsplit参数可以指定切分次数

练习：

编写用户登录程序 温馨提示:
     ⽤户名与密码来源于字符串source_data = 'jason|123'
     想办法从中拆分出⽤户名和密码用于后续账户信息⽐对 
          1.只允许三次失败机会 
          2.登录成功后进⼊入内层循环，用户输⼊任何指令利⽤格式化输出 打印正在执行该⽤户指令即可，直到⽤户输⼊字⺟q退出内层循环
        
实现代码：
    source_data = 'mark|123'
    # 定义一个变量，记录每次输错的次数
    count = 0

    while count<3:  # 最多三次机会
        # 1. 让用户输入用户名和密码
        username = input('请输入用户名:').strip()
        password = input('请输入密码：').strip()

        # 2. 需要把source_data拆分出来
        # 方式一：解压赋值
        real_username, real_password = source_data.split('|')  # ['mark', '123']
        # 方式二：
        # data = source_data.split('|')  # ['mark', '123']
        # real_username = data[0]
        # real_password = data[1]

        # 3. 比对用户名和密码
        if username == real_username and password == real_password:
            print('登录成功')
            while True:
                cmd = input('请输入你的指令：').strip()
                print('正在执行你的指令：%s' % cmd)
                if cmd == 'q':
                    break
        else:
            print('用户名或者密码错误')
            count += 1

字符串的内置方法（尽量掌握）

string = 'abeDK123helloWORLD'

1. 把字符串转为全大写
	string.upper()  

2. 把字符串转为全小写
	string.lower()

3. 判断是否以指定字符开头,返回值为布尔值
	string.startswith('a')  # true
	string.startswith('ae')  # false

4. 判断是否以指定字符结尾，返回值为布尔值
	string.endswith('y')  # false
	string.endswith('LD')  # true

# 小案例：
    old_code = 'ENprs'
    new_code = input('请输入验证码：').strip()

    # if old_code.upper() == new_code.upper():
    if old_code.lower() == new_code.lower():
        print('验证码正确')
    else:
        print('验证码错误')
    
5. format的使用
    5.1 方式一：
        s = 'my name is {}, my age is {}'
        print(s.format('mark', 18))
        # 输出结果： my name is mark, my age is 18

	5.2 方式二：
        s = '{0} my name is {1}, my age is {0}， {1}， {1}， {0}, {2}'
        print(s.format('mark', 18, 'male', ))
        # 输出结果：mark my name is 18, my age is mark， 18， 18， mark, male

	5.3 方式三：
        s = ' my name is {name}, my age is {age}, {name}, {name}, {age}'
        print(s.format(name='mark', age=18))
        # 输出结果： my name is mark, my age is 18, mark, mark, 18
 
6. join() :从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串
    eg:
        name_list = ['hello', 'world', '123', 'abc']
        s1 = name_list[0]
        s2 = name_list[1]
        s3 = name_list[2]
        s4 = name_list[3]
        print(s1 + ',' + s2 + ',' + s3 + ',' + s4 )
        print(','.join(name_list))
        # 执行结果：
        # hello, world, 123, abc
        # hello, world, 123, abc
        
7. replace() :用新字符替换字符串中的旧字符。
    语法：replace('被替代内容','替代内容',修改的个数)
	示例1: 
        s = 'my name is mark mark mark'
        s1 = s.replace('mark', 'tom', 1))
        print(s1)
        # 执行结果： my name is tom mark mark

	示例2：
        m = 'hello'
        n = 'world'
        s = m + n  # helloworld
        m = s.replace('hello', '')
        n = s.replace('world', '')
        print(m, n)

8. isdigit(): 判断字符串是否是纯数字组成，结果返回true或false。
    eg：
        num = '12345abc'
		print(num.isdigit())
        # False
        
实例应用：
    age = input('请输入你的年龄：').strip()
    if age.isdigit():
        print('全是数字')
    else:
        print('不全是数字')

字符串需要了解的内置方法

s = 'helloworldworldworld'

1. find(sub, start, end)：
	功能：指定范围查找子字符串的起始索引，查找成功返回第一个匹配的位置索引，找不到返回-1；若未指定start、end参数，则查找整个字符串。
    
	eg：
        print(s.find('hw'))  # -1
        print(s.find('w'))  # 5
        print(s.find('world'))  # 5

2. index(sub, start, end)
	功能：和find一样，但是不同的是，若找不到会直接报错。
    eg：
        print(s.index('hw')) # 报错：ValueError: substring not found
        print(s.index('w'))  # 5

3. count(): 统计一个字符或字符串在原字符串中出现的次数。
    eg：
    	print(s.count('l'))  # 5
    	print(s.count('world'))  #  3 

3. center,ljust,rjust,zfill
	eg：
    	name='topic'
		name.center(30,'-')  # 总宽度为30，字符串居中显示，不够用-填充
		# 打印结果：-------------topic-------------
		name.ljust(30,'*')  # 总宽度为30，字符串左对齐显示，不够用*填充
		# 打印结果：topic**************************
		name.rjust(30,'*')  # 总宽度为30，字符串右对齐显示，不够用*填充
		# 打印结果：**************************topic
		name.zfill(50)  # 总宽度为50，字符串右对齐显示，不够用0填充
		# 打印结果：0000000000000000000000000000000000000000000000tony
 
4. expandtabs:
	eg:
        name = 'tony\thello'  # \t表示制表符(tab键)
		s = name.expandtabs(1)  # 修改\t制表符代表的空格数
        print(s)
        # 打印结果：tony hello
 
5. captalize：首字母大写
	eg:
		message = 'hello world'
		print(message.capitalize())
		# 打印结果：Hello world
    
6. swapcase：大小写翻转
	eg：
		message1 = 'Hi girl, I want make friends with you!'
		print(message1.swapcase())
		# 打印结果：hI GIRL, i WANT MAKE FRIENDS WITH YOU!  

7. title：每个单词的首字母大写
	eg：
    	msg = 'dear my friend i miss you very much'
		print(msg.title())
		# 打印结果：Dear My Friend I Miss You Very Much 

8. isdecimal，isnumeric，isalnum，isalpha，isidentifier，islower，isupper，isspace，istitle

列表的内置方法

关键字:list
    
1. 类型转换
	print(list(123)) # 不行
	print(list(1.11))# 不行
    print(list('hello')) # ['h', 'e', 'l', 'l', 'o']
    print(list([1, 2, 3 ]))
	print(list({'username': 'ly', 'age': 18})) # ['username', 'age']
	print(list((1, 2, 3)))  # [1, 2, 3]
	print(list({1, 2, 3, 4}))  # [1, 2, 3, 4]

2. 修改
    class_list = ['math', 'english', 'C']
    class_list[0] = 'python'
    class_list[2] = 'physical'
    print(class_list)
	# 执行结果：['python', 'english', 'physical']

3. 添加
	3.1 append(): 列表末尾添加
		class_list = ['math', 'english', 'C']
        class_list.append(123)
        class_list.append([1, 2, 3, 4])
        print(class_list)
        # 执行结果：['math', 'english', 'C', 123, [1, 2, 3, 4]]

	3.2 insert(): 把括号中的元素当成一个整体添加到索引位置,参数一为索引
        class_list = ['math', 'english', 'C']
        class_list.insert(0, 'haha')
        class_list.insert(2, 'haha')
        class_list.insert(6, 'haha')
        print(class_list)
        # 执行结果：['haha', 'math', 'haha', 'english', 'C', 'haha']

	3.3 extend(): 合并两个列表
		class_list = ['math', 'english', 'C']
        class_list.extend([1, 2, 3 ,4])
        print(class_list)
        # 执行结果：['math', 'english', 'C', 1, 2, 3, 4]
		内部原理：
        	class_list = ['math', 'english', 'C']
            l = [1, 2, 3, 4]
            for i in l:
                class_list.append(i)
            print(class_list)

4. 删除：
	4.1 del关键字
		class_list = ['math', 'english', 'C']
        del class_list[0]
        print(class_list)
        # 执行结果：['english', 'C']

	4.2 remove(): 括号内指出要删除哪个元素，没有返回值
        class_list = ['math', 'english', 'C']
        class_list.remove('C')
        print(class_list)  # ['math', 'english']
        print(name_list.remove('C'))  # None
        
	4.3 pop()：默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
        class_list = ['math', 'english', 'C','physical']
        class_list.pop(2)  # 删除索引为2的元素
        class_list.pop()  # 删除最后一个元素
        print(class_list)  # ['math', 'english']
        print(class_list.pop(1))  # english
        
5. reverse(): 反转列表中元素顺序
    l1 = [11, 22, 33, 44, 55, 66]
    l1.reverse()
    print(l1)
    # 执行结果：[66, 55, 44, 33, 22, 11]
    
6. sort(): 排序
    注意：列表排序，必须保持列表中元素类型一致，否则无法排序。
    - 默认升序排序:
        l1 = [11, 22, 33, 44, 77, 55, 66]
        l1.sort()
        print(l1)  # [11, 22, 33, 44, 55, 66, 77]
    
    - reverse参数：reverse=True 降序排序
    	l1 = [11, 22, 33, 44, 77, 55, 66]
        l1.sort(reverse=True)
        print(l1)  # [77, 66, 55, 44, 33, 22, 11]

7. 列表比较：逐个元素比较，直到比较出结果
	l1 = [999, 888]
    l2 = [111, 222, 333, 444, 555]
    print(l1 > l2)  # True
    
8. 列表切片：顾头不顾尾，步长
	l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    print(l[1])  # 2
    print(l[1:5])  # [2, 3, 4, 5]
    print(l[1:])  # 冒号右边不写，代表从开始位置一直切到末尾 [2, 3, 4, 5, 6, 7, 8, 9]
    print(l[:5])  # 冒号左边不写，代表从头开始一直切断索引指定位置  [1, 2, 3, 4, 5]
    print(l[1:8:2]) # 每个索引间隔步长为2 [2, 4, 6, 8]
    print(l[-1])  # -1位置取得就是末尾数据  9
    print(l[-8:-1:2])  # [2, 4, 6, 8]
    print(l[::-1])  #  冒号左右两边都不写，代表全都要，负号表示倒序 [9, 8, 7, 6, 5, 4, 3, 2, 1]
	print(l[:])  # 冒号左右两边都不写，代表全都要 [1, 2, 3, 4, 5, 6, 7, 8, 9]

字典的内置方法(掌握)

dic = {
    'name': 'xxx',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
1. 取值：
	1.1 方式一：字典变量名['key值']
    	key值不存在则报错

	1.2 方式二：字典变量名.get('key值',默认值)
    	key值不存在返回None，并且可以设置默认值

2. 修改值：字典变量名['key值'] = value值
	-  key值存在，直接进行修改操作
    -  k值不存在，会往字典中添加一个key:value


3. len():求长度，若参数为列表的话返回值为元素个数，字典的话返回值为key：value键值对的个数


4. 成员运算 in、not in
	- in ： 判断某个值是字典中的key
    - not in ：判断某个值不是字典的key
    eg:
        print('name' in dic)  # True
        print('name' not in dic)  # False 

5. 删除
	5.1 del关键字
        del dic['name']
        del dic['hobbies']

	5.2 pop()
        dic.pop('name')
        dic.pop('hobbies')

6. 字典三剑客
	6.1 keys(): 获取字典中的所有key，以列表形式存储
		print(dic.keys())  # dict_keys(['name', 'age', 'hobbies']) => 列表
    
    6.2 values(): 获取字典中所有的value，以列表形式存储
		print(dic.values()) # dict_values(['xxx', 18, ['play game', 'basketball']]) =>列表
    
    6.3 items(): 获取字典中所有的键值对，以列表套元组形式存储
        print(dic.items())  # dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])

7. 循环字典
	注意：循环字典循环的是字典的key
        for i in dic:
            print(i)
            print(dic[i])
            print(dic.get(i))


        for k, v in dic.items():
            print(k, v)

        for i in dic.keys():
            print(i)

        for j in dic.values():
            print(j)

字典需要了解的方法

dic = {
    'name': 'xxx',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
1. pop('key'): 删除指定的key对应的键值对,并返回值

2. popitem(): 随机删除一组键值对,并将删除的键值放到元组内返回

3. update(): 用新字典更新旧字典，有则修改，无则添加
    dic1 = {
        'name':'aaa'
    }
    dic1.update({'name': 'mark', 'pwd': 123})

4. fromkeys()
	dic1 = dict.fromkeys(['k1', 'k2', 'k3'], [])
	print(dic1)
    # {'k1': [], 'k2': [], 'k3': []}
    dic1['k1'] = []
   	dic1['k1'].append(666)
    # dic1['k1'].append(777)
    # dic1['k1'].append(888)
    # print(dic1)

5. setdefault():
    - key不存在则新增键值对，并将新增的value返回
    - key存在则不做任何修改，并返回已存在key对应的value值
		dic.setdefault('name1111', 666))

元组的内置方法

1.类型转换
    关键字：tuple
        tuple(111)   # 不行
        tuple(1.11)  # 不行
        tuple('helloworld') # 行

    总结：支持for循环的数据类型都可以转为元组

# 笔试题：
t1 = (111)
t2 = (1.22)
t3 = ('helloworld')
t4 = ('a', 'b')
t5 = ('c', )
'''当元组中只有一个元素的时候，也要加逗号'''
print(type(t1))  # 
print(type(t2))  # 
print(type(t3))  # 
print(type(t4))  # 
print(type(t5))  # 


2. 长度：len(tuple1) 

# 笔试题
t1 = (111, 222, [444, 555, 666])
# print(t1)
# print(t1[2])
t1[2].append(777)
print(t1)

集合的内置方法

集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求

d = {} # 默认是空字典 
s = set() # 这才是定义空集合

# 题目：去重，并且保留原来的顺序
    ll = [11, 22, 22, 22, 33, 33, 44, 44, 55, 66, 77, 77, 88]

    一：去重成功，但未保持原来顺序
    ss = set(ll)
    l1 = list(ss)
    print(l1) # [33, 66, 11, 44, 77, 22, 55, 88]
	
    二：既去重，又保持原来顺序
        new_list = []
        for i in ll:
            if i not in new_list:
                new_list.append(i)
        print(new_list)

集合的关系运算

list1 = {"123", "456", "789", "abc"}
list2 = {"456", "abc", "ABC", "QWE"}
# 求合集，并集
print(list1 | list2)

# 求交集
print(list1 & list2)

# 求list1差集：list1独有
print(list1 - list2)

# 求list2差集：list2独有
print(list2 - list1)

# 求对称差集
print(list1 ^ list2)

# 求父集，子集： 存在包含或被包含关系返回True，不存在包含或被包含关系返回False
print(list1 > list2)
print(list1 < lists2)

# 执行结果：
{'789', 'QWE', 'ABC', 'abc', '456', '123'}
{'abc', '456'}
{'789', '123'}
{'QWE', 'ABC'}
{'789', 'QWE', 'ABC', '123'}
False
False