数据类型基本操作及内置方法

数据类型基本操作及内置方法

数据类型本身都含有一系列的操作方法，内置方法是其中最多的。这些操作方法和内置方法都是python提供给我们的。

而python中数据类型调用内置方法的统一句式：句点符

如：

'str type'.字符串内置方法  # 用点‘.’跟在数据后面，再跟方法名
即
数据值.对应数据类型的内置方法

整型方法

类型转换

int(其他数据类型)
ps：浮点型可以直接转，字符串必须是纯数字才能转
int(11.72)  # 11
int('123')  # 123
int('10.1')  # 报错，因为小数点字符不是数字

进制数转换

# 进制转换关键字
bin(100)  # 0b1100100   在python中0b开头的数字表示二进制
oct(100)  # 0o144           以0o开头的数字表示八进制
hex(100)  # 0x64			  以0x开头的数字表示八进制
# 其他进制转换成10进制
int(0b1100100)  # 方式1，直接对其他进制的整型进行转换
int('0b1100100', 2)  # 方式2，对字符串的进制进行说明
int(0o144)  # 100
int('0o144', 8)  # 100

浮点型方法

类型转换

float(整型或字符串)
# 字符串中只能有一个小数点，其他的必须是纯数字

ps：python自身对数字的敏感度底，精确度低，如果想做一些精确的运算，需要借助一些模块如numpy

print(1.1 - 1)  # 0.10000000000000009

字符串方法

类型转换

所有的数据类型都可以转成字符串。

# 这里简单举几个例子
>>> str(1000)
'1000'
>>> str([111,222])
'[111, 222]'
>>> str({'name':'jason','age':40})
"{'name': 'jason', 'age': 40}"

字符串基础操作

>>> s1 = 'leethon is handsome'  # 实验字符串
1.索引取值
    s1[0]  # 'l'
    s1[5]  # 'o'
    s1[-1]  # 'e'  python支持负数索引，代表倒数

2.切片操作  # 用冒号隔开两个数字，分别是要取的头和尾的索引
    s1[0:7]  # 取从索引从0到6的字符，顾头不顾尾
    'leethon'
    s1[-7:-3]  # 取索引从倒数第7到倒数第4，注意默认只能从左到右
    'ands'
- 修改方向或步长  # 用两个冒号隔开三个数字，最后一个数字指方向与步长
    s1[-1:-4:-1]  # 最后一个-1代表从后往前取，从倒数第1到倒数第3，依然顾头不顾尾
    'emo'
    s1[7:3:-1]
    ' noh'
    s1[0:-1:2]  # 从0到倒数第2的索引，每次跳一个字符取
    'lehni ado'
- 省略数字的写法
以上的写法中，由于左闭右开这一特性，导致取法无法取，如'handsome'没法取到e
    s1[-8:]  # 冒号后面的数字省略代表取到最后一个字符
    'handsome'
    s1[:8]  # 冒号前的数字省略代表从最前取到索引为7的字符
    'leethon '
	s1[::-1]  # 冒号的数字全省略，并倒序
	'emosdnah si nohteel'
3.统计字符串的长度（个数）
	len(s1)  # 19    得到字符串中有19个字符，注意空格也是字符

字符串内置方法

1.移除字符串首尾的字符（默认移除空格）—— strip
        '  密码    '.strip()  # 默认清除空格回车等看不见的字符
        '密码'
        '￥￥jason￥￥'.strip('￥')  # 可以指定清除什么字符
        'jason'
        应用场景：要求用户输入时，用户也许会不小心输入看不见的空格
    - 只移除左或右的字符
        '   leethon  '.lstrip()  # 只移除左边空格
        'leethon  '
        '   leethon  '.rstrip()  # 只移除右边空格
        '   leethon'
        # 中间指定的字符如默认的空格是不会被移除
        '  贴  贴 '.strip()  # 贴贴失败
        '贴  贴'
    
2.按指定的字符分割字符串生成一个列表 —— split
        'leethon is handsome'.split(' ')   # 将字符串按空格分割
        ['leethon', 'is', 'handsome']  # 得到一个列表
        'jason|30|123'.split('|')  # 将字符串按'|'分割
        ['jason', '30', '123']  # 得到一个列表
    - 切指定的次数
        'jason|30|123'.split('|',  1)  # 从左到右只切一次
        ['jason', '30|123']  
        'jason|30|123'.rsplit('|',  1)  # 从右到左只切一次
        ['jason|30', '123']  
    
3.字符串格式化输出 —— format
    - 等价于占位符
        'my name is {}.my age is {}.'.format('leethon', '18')  # 自动根据顺序填充
        'my name is leethon.my age is 18.'
    - 索引取值并支持反复使用
        'my name is {1}.my age is {0}.'.format('18', 'leethon')  # 根据索引填充
        'my name is leethon.my age is 18.'
        'i love {0},and she love {0},too!'.format('eating')  # 可以重复使用某索引
        'i love eating,and she love eating,too!'
    - 关键字取值
        'my name is {name}.my age is {age}.'.format(name = 'leethon', age = '18') 
        'my name is leethon.my age is 18.'  # 见名知意
    - f''用法——最常用方法（！！！）
        name = 'jason'
        age = 30
        f'{name} is {age} years old'  # 这个方法可以随时引用前面赋值过的变量
        'jason is 30 years old'
    
# 后续的内置方法使用频率稍低一些
4.大小写相关
    - 转换大小写 —— upper,lower
        'lee123'.upper()  # 将字符串中的小写字母全部转换为大写
        'LEE123'
        'LEE456'.lower()  # 将字符串中的大写字母全部转换为小写
        'lee456'
	- 使用场景 —— 验证码
        code = 'Er7bQ5'
        print(code)
        inp_code = input('输入上面的验证码：')
        if code.upper() == inp_code.upper():
            print('好康的已经发到你的手机上，注意查收')
        -------------
        Er7bQ5
        输入上面的验证码：er7bq5
        好康的已经发到你的手机上，注意查收
        ---------------
    - 判断大小写 —— isupper,islower
        'lee123'.isupper()
        False  # 判断除了数字以外的字母是否全大写
        'LEE456'.isupper()
        True
        'lee李123'.islower()
        True  # 只判断字符串中的字母的大小写

5.判断纯数字 —— isdigit
        'oops1234'.isdigit()
        False
    - 猜年龄并规范用户输入
        age = 18
        while True:
            num = input('请猜年龄：').strip()  # 将用户输入的两侧空格去掉
            if num.isdigit():  # 判断如果是纯数字再比对答案
                if int(num) == age:
                    print('猜对了')
                    break
            else:  # 如果不是数字，进行友好的提示，进入下一次循环
                print('不懂怎么打数字，你好菜哦')

6.替换字符串中指定的内容 —— replace
        'jason is handsome'.replace('jason', 'leethon')  # 第一个参数是旧字符串，第二参数是新字符串
        'leethon is handsome'  # 将字符串中的Jason换成新的leethon
        
7.字符串的拼接
    - 用运算符  # 不建议，因为底层效率较低
        s1 = '贴'
        s1 + s1  # 支持字符串之间相加
        '贴贴'
        s1 * 3  # 支持字符串和整型相乘
        '贴贴贴' 
    - 内置方法 —— join  # 这个拼接的效率高些
        '/'.join(['heihei', 'haha', 'huhu'])  # 可以看做split的逆运算
        'heihei/haha/huhu'  # 将列表中的字符用'/'粘起来
        # 注意
        '/'.join(['heihei', 'haha', 111])  # 当列表中所有都是字符串时才能粘
        TypeError:expected str instance, int found  # 当有其他数据类型会报错
        # 如果要直接拼接某些字符，用空字符串黏连就可以了
        ''.join(['h', 'e', 'l', 'l', 'o'])
        'hello'
        
8.统计指定字符出现的次数 —— count
        'blabalblablabla'.count('l')  # 可以对一个字母数
        6
        'blaballblablabla'.count('bla')  # 也可以对字母组合数
        4
        '嘿嘿嘿'.count('嘿嘿')  # 当然也可以对汉字组合
        1  # 一个字符只能归属于一个组合

9.判断字符串的开头和结尾 —— startswith,endswith
        'leethon'.startswith('lee')
        True
        'jason'.endswith('son')
        True
	- 问：如何判断大字符串是否包含小字符串
    	'go' in 'go to bed'  # 用成员运算符
		True
# 后续的使用频率更低了
10.大小写相关2
    - 每个单词首字母大写 —— title
        'so sorry'.title()
        'So Sorry'
    - 首个单词首字母大写 —— capitalize
        'i have no idea'.capitalize()
        'I have no idea'
    - 转换所有字母的大小写 —— swapcase
        'GoGoGo'.swapcase()
        'gOgOgO'
        'GoGoGo'.swapcase().swapcase()
        'GoGoGo'

练习

# 基于字符串充当数据库完成用户登录(基础练习)
#    data_source = 'jason|123'  # 一个用户数据
#    获取用户用户名和密码 将上述数据拆分校验用户信息是否正确
data_source = 'jason|123'
name, pwd = data_source.split('|')
while True:
    username, inp_pwd = [
        input('请输入用户名：').strip(),
        input('请输入密码：').strip()
    ]
    if username == name and inp_pwd == pwd:
        print('login success!')
        break
    else:
        print('用户名或者密码输入错了')

# 基于列表充当数据库完成用户登录(拔高练习)  # 多个用户数据
data_source = ['jason|123', 'kevin|321', 'oscar|222']
while True:
    identity = '|'.join([
        input('请输入用户名：').strip(),
        input('请输入密码：').strip()
    ])
    if identity in data_source:
        print('登录成功！')
        break
    else:
        print('用户名或密码输入错误')

列表内置方法

类型转换

list(其他数据类型)
包括能够被遍历（能被for循环的）的类型，如元组、字符串、字典、集合
list('hello')  # 将每个字符取出作为元素
['h', 'e', 'l', 'l', 'o']
list(('hello','world'))
['hello', 'world']
list({'name':'leethon', 'age':'18'})
['name', 'age']  # 只将键取出作为元素
list({1, 2, 3, 4, 5})
[1, 2, 3, 4, 5]

# list类型转换相当于
l1 = []
for i in 被遍历对象:
    l1.append(i)
然后将l1给我们

列表基础操作

# 和字符串的取值、切片、len一致
l1 = [1, 2, 3, 4, 5, 6, 7]  # 示例列表
1.索引取值
        l1[0]
        1
        l1[5]
        6
        l1[9]  # 超出范围报错
        error:list index out of range.
        
2.切片操作
        l1[0:5]  # 左闭右开，索引从0到4
        [1, 2, 3, 4, 5]
        l1[3:-1]  # 支持负数索引，表示倒数第几个
        [4, 5, 6]
        l1[:3:-1]  # 支持省略写法，第一个参数正序时从索引0，反序时从索引-1
        [7, 6, 5]
        l1[::2]  # 支持改步长，即索引的间隔
        [1, 3, 5, 7]  # 省略第二个参数的写法，正序时到索引-1，反序时到索引0

3.统计列表长度（元素个数）
		len(l1)  # 列表中有7个元素
		7
4.对某个数据值修改
		l1[0] = 11  # 指定索引进行修改
    	[11, 2, 3, 4, 5, 6, 7]  # l1的索引0处发生变化

列表内置方法

1.列表添加数据值
    - 尾部添加单个数据值 —— append
        >>> l1 = [111, 222]
        >>> l1.append(333)  # 在l1列表尾部插入数据333
        >>> l1
        [111, 222, 333]  # 新增的数据在列表的尾部
        >>> l1.append([444, 555])  # 输入列表参数
        >>> l1
        [111, 222, 333, [444, 555]]  # 仍然会作为整体元素插入尾部
    - 任意位置添加数据值 —— insert
        >>> l1.insert(1, '插队数据')  # 第一个参数是插入的索引位置，第二个参数是插入值
        >>> l1
        [111, '插队数据', 222, 333]  # 新增的数据在索引1的位置上，原本的位置往后顺延
    - 扩展列表
        - 运算符  # 依然不建议使用，底层效率低 
            >>> l1 = [11, 22]
            >>> l2 = [33, 44]
            >>> l1 + l2
            [11, 22, 33, 44]
        - 内置方法 —— extend
            >>> l1.extend(l2)
            >>> l1  # 这个操作会修改l1
            [11, 22, 33, 44]  # 将l2列表中的值遍历出来插入l1
            - 底层机制
            # extend所完成的事相当于
                for i in l2: 
                    l1.append(i)
        
2.删除列表数据
    - 通用删除关键字 —— del
        >>> l1 = [1, 2, 3, 4]
        >>> del l1[0]  # 按照索引删除元素
        >>> l1
        [2, 3, 4]  # 后续元素往前填充
    - 数据值查找删除 —— remove
        >>> l2 = ['jason', 'kevin', 'leethon']
        >>> l2.remove('kevin')  # 根据内容删除
        >>> l2
        ['jason', 'leethon']
    - 索引查找弹出 —— pop
        >>> l3 = ['happy', 'smile', 'delight', 'glad']
        >>> l3.pop(1)  # 按索引弹出列表元素
        'smile'  # 执行pop后会拿到这个元素
        >>> l3
        ['happy', 'delight', 'glad']  # 列表的对应元素也消失了
        >>> l3.pop()  # 括号里不加参数
        'glad'  # 默认弹出最后一个元素
        >>> l3
        ['happy', 'delight']
3.排序 —— sort
        >>> l1 = [1, 3, 2, 7, 4, 5, 6]
        >>> l1.sort()
        >>> l1
        [1, 2, 3, 4, 5, 6, 7]
    - 降序排列
        >>> l1.sort(reverse = True)  # 翻转定为真，代表降序排列
        >>> l1
        [7, 6, 5, 4, 3, 2, 1]
    - 字符串排列
        >>> l2 = ['ab', 'aaa', 'aab', 'bb', 'abb', 'ba']
        >>> l2.sort()
        >>> l2
        ['aaa', 'aab', 'ab', 'abb', 'ba', 'bb']  
        # 按位比较，ASCII码值小的在前，每位都相同，长度短的在前面
4.统计某数据值出现次数
        >>> l1 = ['kk', 'k', 'kkkk', 'k', 'kkk', 'kkkk', 'k']
        >>> l1.count('k')
        3  # 只会按照元素为最小单位来数，不会将字符串元素拆成单个字符
5.颠倒顺序
        >>> l1 = [9, 9, 6]
        >>> l1.reverse()
        >>> l1
        [6, 9, 9]  # 将列表的元素排列颠倒过来

可变类型与不可变类型

在刚才内置方法的变化中，我们发现，在字符使用修改数据的内置方法的时候，原本的字符串变量并没有变：

s1 = 'hhhh'
print(s1.upper())  # HHHH
print(s1)  # hhhh   	
# s1打印出来仍然是小写的

而列表在使用修改的内置方法的时候，原列表是会变化的：

l1 = [1, 2, 3, 4]
l1.pop()
print(l1)  # [1, 2, 3]
# l1已经发生了变化

发生这样的原因是因为，字符串是不可变类型的数据类型，它在受到修改的时候会产生新的数据值，而原本的数据值不会被影响，依旧保持和原变量的绑定。

而列表是可变类型的数据类型，它在受到修改时会在原本的数据值中修改。

拔高练习

# 利用列表编写一个员工姓名管理系统
#     输入1执行添加用户名功能
#     输入2执行查看所有用户名功能
#     输入3执行删除指定用户名功能
#     '''分析 用户输入的不同 可以执行不同的代码'''
#     ps: 思考如何让程序循环起来并且可以根据不同指令执行不同操作
#     提示: 循环结构 + 分支结构
staff = [['jason', '123'],
         ['kevin', '123'],
         ['leethon', '123'],
         ['hunk', '123']
         ]
while True:
	# 展示功能，并要求输入
    order = input("""请选择功能：
    0：退出
    1：添加用户名
    2：查看所有用户
    3：删除指定用户名
    """)
	# 如果输入了功能以外的字符，则要求重新输入
    if order not in ['1', '2', '3', '0']:
        print('请输入有效代码')
        continue
	# 添加用户名功能
    if order == '1':
        username, inp_pwd = [
            input('请输入用户名：').strip(),
            input('请输入密码：').strip()
        ]
        staff.append([username, inp_pwd])
    # 查看所有人功能
	elif order == '2':
        for member in staff:
            print(member[0])
	# 注销账户功能
    elif order == '3':
        username = input('你要删除的用户名是：')
        del_member = None
        for member in staff:
			# for循环体中不能对遍历的列表进行修改
            if member[0] == username:
                del_member = member  # 记录要注销的账户
                break
        if del_member:
            staff.remove(del_member) # 当for循环结束后再对staff进行修改
            print(f'用户{del_member[0]}已被注销')
	# 退出程序的出口
    else:
        print('你已经退出程序')
        break