内置方法

数据类型的内置方法

　　"""

　　如何查看数据类型都有哪些内置方法
　　　　句点符(.)
　　"""

整型int

　　1.类型转化 int()

res = int(res)

　　'''int只能转换纯整数，小数不行，不是数字以为的数据也不行'''

　　2.进制转化

print(bin(100))  # 将十进制的100转换成二进制  0b1100100
print(oct(100))  # 将十进制的100转换成八进制  0o144
print(hex(100))  # 将十进制的100转换成十六进制  0x64
# 0b开头为二进制数  0o开头为八进制数  0x开头为十六进制数
print(int('0b1100100', 2))  # 100
print(int('0o144', 8))  # 100
print(int('0x64', 16))  # 100

浮点型float

　　类型转化 float()

res = float(res)

　　'''整型可以转化为浮点型，其他不行'''

字符串str

　　1.类型转化 str()

        print(str(123))
        print(str(123.21))
        print(str([1, 2, 3, 4]))
        print(str({'name': 'jason', 'pwd': 123}))
        print(str((1, 2, 3, 4)))
        print(str(True))
        print(str({1, 2, 3, 4}))

　　'''所以类型都可以转化'''

　　2.索引取值变量名[]

res = 'hello world!'
print(res[1])  # e

　　3.索引支持负数变量名[-1]

res = 'hello world!'
print(res[-1])  # !  最后一位
print(res[-5:-1])  # orld  顾头不顾尾
print(res[-5:-1:-1])  # 方向冲突

　　4.切片操作顾头不顾尾变量名[1:4]

res = 'hello world!'
print(res[1:4])  # ell

　　5.步长操作变量名[1:10:2]

res = 'hello world!'
print(res[1:10])  # ello worl
print(res[1:10:2])  # el ol

　　6.统计字符串内部字符的个数 len()

res = 'hello world!'
print(len(res))  # 12

　　7.移除字符串首尾指定的字符 .strip()

name = '  jason  '
print(name, len(name))
print(len(name.strip()))  # 默认移除首尾的空格
name1 = '$$jason$$'
print(name1.strip('$'))  # jason
print(name1.lstrip('$'))  # jason$$
print(name1.rstrip('$'))  # $$jason

　　8.按照指定的字符切割字符串 .split()

　　　　该方法的结果是一个列表

res2 = 'jason|123|18'
print(res2.split('|'))  # ['jason', '123', '18']
print(res2.split('|', maxsplit=1))  # ['jason', '123|18']  maxsplit用于控制切割的次数
print(res2.rsplit('|', maxsplit=1))  # ['jason|123', '18']

　　9.大小写 .upper()转大写 .lower()转小写 .isupper()判断是否大写 .islower()判断是否小写

res = 'JasOn123 JAson'
res1 = 'jason123'
# 转全大写
print(res.upper())  # JASON123 JASON
# 转全小写
print(res.lower())  # jason123 jason

　　"""

　　实际案例:图片验证码忽略大小写

　　思路:全部转大写或者小写再比对
　　"""

old_code = 'JaSon123'
print('这是返回给用户的图片验证码:%s' % old_code)
new_code = input('请输入验证码>>>:').strip()
if old_code.upper() == new_code.upper():  # 这里也可以使用lower()
     print('验证码正确')
else:
     print('验证码错误')
# 判断是否是纯大写
print(res.isupper())
print(res1.isupper())
# 判断是否是纯小写
print(res.islower())
print(res1.islower())

　　10.判断字符串是否以指定的字符开头 .startswith()开始 .endswith()结尾

s1 = 'jason 123 newapeman heiheihei oldgirl'
print(s1.startswith('tony'))  # False
print(s1.startswith('j'))  # True
print(s1.startswith('jas'))  # True
print(s1.startswith('jason'))  # True
# 3.判断字符是否以指定的字符结尾
print(s1.endswith('oldboy'))  # False
print(s1.endswith('l'))  # True
print(s1.endswith('rl'))  # True
print(s1.endswith('oldgirl'))  # True

　　11.格式化输出 .format()

　　　　{} 相当于占位符 %s

　　　　　　{}内可以索引取值也可以变量名取值

　　　　　　format()括号内相当于列表

# 1.与用户交互 占位符 %s %d
# 2.字符串内置方法 format()
# 第一种玩法 相当于%s占位符
s2 = 'my name is {} my age is {}'
print(s2.format('jason',18))  # my name is jason my age is 18
# 第二种玩法 大括号内写索引值可以打破顺序 并且可以反复使用相同位置的数据
s3 = '{1} my name is {1} my age is {0} {0} {0} {1} {1}'
print(s3.format('jason', 18))
# 第三种玩法 大括号内写变量名
s4 = '{name1} my name is {name1} my age is {age} {name1} {name1}'
print(s4.format(name1='jason', age=18))
'''占位符与format结合具体情况挑选使用'''

　　12.字符串的拼接 .join()

　　　　join(连接符，列表名)

　　　　　　但是连接符和列表元素都必须为字符串

# 方式1  字符串相加
print('hello' + 'world')
# 方式2  join方法
l = ['jason', 'tony', 'kevin', 'tom', 'jack']
print(l[0] + '|' + l[1] + '|' + l[2] + '|' + l[3] + '|' + l[4])
print('|'.join(l))
l1 = ['jason', 123, 'tony']
print('$'.join(l1))  # 报错
"""必须是字符串类型 (在python不同数据类型之间无法直接操作)"""

　　13.替换字符串中指定的字符 .replace()

　　　　replace(原字符，新字符)

s4 = 'my name is tony tony tony my age is 18'
# 替换字符串中所有的tony>>>jason
print(s4.replace('tony', 'jason'))  # my name is jason jason jason my age is 18
# 替换指定个数的文本
print(s4.replace('tony', 'jason', 1))  # my name is jason tony tony my age is 18

　　14.判断字符串中是否是纯数字 .isdigit()

s5 = 'jason123'
print(s5.isdigit())  # False
s6 = '123'
print(s5.isdigit())  # True
'''实际案例'''
guess_age = input('请输入猜测的年龄>>>:').strip()
if guess_age.isdigit():
    guess_age = int(guess_age)
else:
    print('你能不能好好输')

　　# 了解

　　字体格式相关

　　 .title()所有单词首字母大写 .capitalize()开头的单词首字母大写 .swapcase()大小写互换

s5 = 'my name is jason my age is 18'
print(s5.title())  # My Name Is Jason My Age Is 18  所有单词首字母大写
print(s5.capitalize())  # My name is jason my age is 18  开头的单词首字母大写
s6 = 'JaSOn iS Sb'
print(s6.swapcase())  # jAsoN Is sB  大小写互换

　　.find()查看 .index()查看 .count()统计字符出现次数

s7 = 'my name is jason sb sb sb somebody sb sb sb sb sone sb sone'
print(s7.find('s'))  # 查看指定字符对应的起始索引值  从左往右找到一个就结束
print(s7.find('sb'))  # 查看指定字符对应的起始索引值  从左往右找到一个就结束
print(s7.find('w'))  # 找不到返回-1
print(s7.index('w'))  # 找不到直接报错
# 统计某个字符出现的次数(记忆)
print(s7.count('sb'))

　　.center()居中显示 .ljust()左对齐 .rjust()右对齐

print(s8.center(15, '$'))  # 居中展示
print(s8.ljust(15, '&'))  # 左对齐   jason&&&&&&&&&&
print(s8.rjust(15, '*'))  # 右对齐   **********jason

　　.isalnum() # 字符串中既可以包含数字也可以包含字母

　　.isalpha() # 字符串中只包含字母

列表list

　　1.类型转化 list()

# 列表内一般都会存储相同数据类型的数据
# 类型转换  数据类型关键字(需要转换的数据)
print(list(123))  # 报错
print(list(123.21))  # 报错
print(list('hello'))  # ['h', 'e', 'l', 'l', 'o']
print(list({'username': 'jason', 'pwd': 123}))  # ['username', 'pwd']
print(list((11, 22, 33)))  # [11, 22, 33]
print(list({11, 22, 33}))  # [33, 11, 22]
'''list关键字可以将支持for循环的数据类型转换成列表'''

　　2.修改值列表名[索引] = 修改后的变量值

name_list[0] = 666
print(name_list)  # [666, 'kevin', 'tony', 'jack']

　　3.添加值 .append() .insert() .extend()

　　　　append() 尾部添加

　　　　insert(插入位置索引值，插入元素)

　　　　extend()将一个列表中每个元素依次使用append()添加到原列表中

# 方式1  尾部追加(将括号内的数据当成一个整体追加到列表末尾)
name_list.append(666)
print(name_list)  # ['jason', 'kevin', 'tony', 'jack', 666]
name_list.append([666, 777, 888, 999])
print(name_list)  # ['jason', 'kevin', 'tony', 'jack', [666, 777, 888, 999]]
# 方式2  插入元素(将括号内的数据当成一个整体插入到索引指定位置)
name_list.insert(0, 'heiheihei')
print(name_list)  # ['heiheihei', 'jason', 'kevin', 'tony', 'jack']
name_list.insert(2, 'hahaha')
print(name_list)  # ['jason', 'kevin', 'hahaha', 'tony', 'jack']
name_list.insert(0, [11, 22, 33])
print(name_list)
# 方式3  扩展元素(相当于for循环+append操作)
name_list.extend([111, 222, 333, 444, 555])
print(name_list)  # ['jason', 'kevin', 'tony', 'jack', 111, 222, 333, 444, 555]
l1 = [111, 222, 333, 444, 555]
l2 = [1, 2, 3, 4, 5]
for i in l2:
    l1.append(i)  # 将l2中元素追加到l1末尾
print(l1)

　　4.删除值 del 列表名[索引值] .remove() .pop()

　　　　del 列表名[索引值] 通过索引值直接删除

　　　　remove(需要删除元素) 指名道姓的删除

　　　　pop(索引值) 从原列表中按索引值取出元素可以使用 ，原列表中没有该元素了，没填索引值则默认最后一个元素弹出　　

# 方式1  通用删除方式
del name_list[1]  # 根据索引直接删除  del是关键字delete缩写
print(name_list)  # ['jason', 'tony', 'jack']
# 方式2  remove()  括号内指定需要移除的元素值
name_list.remove('jason')
print(name_list)
print(name_list.remove('jason'))  # None
# 方式3  pop()  括号内指定需要弹出的元素索引值   括号内如果不写参数则默认弹出列表尾部元素
name_list.pop(1)
print(name_list)
name_list.pop()
print(name_list)
print(name_list.pop())  # jack

　　5.排序 .sort()

　　　　默认升序

　　　　（reverse=True）参数指定降序

l1 = [44, 22, 11, 33, 99, 77, 88, 66]
l1.sort()
l1.sort(reverse = True)
print(l1)

　　6.顺序颠倒 .reverse()

l1 = [44, 22, 11, 33, 99, 77, 88, 66]
l1.reverse()  # 顺序颠倒
print(l1)

　　7.切片

l1 = [44, 22, 11, 33, 99, 77, 88, 66]
print(l1[1:5])
print(l1[::-1])  # 冒号左右两边不写数字默认全都要
print(l1[:5])  # [44, 22, 11, 33, 99]  左边不写默认从头开始
print(l1[1:])  # [22, 11, 33, 99, 77, 88, 66]  右边不写默认到尾部

　　8.列表比较

　　　　列表比较运算采用相同索引元素比较只要有一个比出了结果就直接得出结论

ll1 = [999, 111]
ll2 = [111, 222, 333, 444, 555, 666, 777, 888]
print(ll1 > ll2)  # True

　　9.引申出字符串比较

　　　　字符串比较大小也是按照索引位置内部转成ASCII对应的数字比较

s1 = 'hello world'
s2 = 'abc'
print(s1 > s2)   # Ture

字典dict

　　1.按k取值 k不存在会直接报错

　　　　字典名[k值]

dic = {
        'name': 'jason',
        'age': 18,
        'hobbies': ['play game', 'basketball']
        } 
print(dic['name'])
print(dic['pwd'])

　　2.按k修改值新增键值对(使用频率最高)

　　　　字典名[k值] = [新值]

dic = {
        'name': 'jason',
        'age': 18,
        'hobbies': ['play game', 'basketball']
        }
dic['name'] = 'jasonNB'  # 键存在为修改值
print(dic)
dic['hobbies'].append('read')
print(dic)
dic['pwd'] = 123  # 键不存在为新增键值对
print(dic)

　　3.统计字典内部键值对的个数 len()

dic = {
        'name': 'jason',
        'age': 18,
        'hobbies': ['play game', 'basketball']
        }
print(len(dic))  # 3

　　4.成员运算默认只暴露k

dic = {
        'name': 'jason',
        'age': 18,
        'hobbies': ['play game', 'basketball']
        }
print('jason' in dic)
print('name' in dic)

　　5.删除元素 del 字典名['k值'] .pop() .popitem()

　　　　del 字典名['k值'] 按k值直接删除

　　　　pop(k值) 按k弹出v值 v值可以使用

　　　　popitem(k值) 按k弹出k，v组织成元组的形式(k， v)

dic = {
　　　　'name': 'jason',
　　　　'age': 18,
　　　　'hobbies': ['play game', 'basketball']
　　　　}

# 方式1
del dic['name']
print(dic)
# 方式2  指定k弹出键值对 给出v
print(dic.pop('age'))
print(dic)
# 方式3  弹出键值对 组织成元组的形式 第一个元素是k第二个元素是v(了解)
print(dic.popitem())
print(dic)

　　6.获取v值 .get()

　　　　没找到不会报错，反馈None

　　　　get(k值，自定义返回对象)

dic = {
        'name': 'jason',
        'age': 18,
        'hobbies': ['play game', 'basketball']
        }
print(dic['name'])  # jason  键不存在直接报错  按k取值不太推荐使用该方式
print(dic['xxx'])  #  键不存在直接报错  按k取值不太推荐使用该方式
print(dic.get('name'))  # jason
print(dic.get('xxx'))  # None  键不存在 不会报错返回None
print(dic.get('name', '哈哈哈'))  # 第二个参数 可以在k不存在的时候自定义返回信息
print(dic.get('xxx', '哈哈哈'))  # 第二个参数 可以在k不存在的时候自定义返回信息

　　7.keys() values() items()

　　　　keys() 取出所有k值组织成列表形式

　　　　values() 取出所有的v值组织成列表的形式

　　　　items() 取出所有的键值对组织成元组(k，v)再写入列表之中

　　　　以上结果在python2中是列表在python3中是迭代器(老母猪)

print(dic.keys())  # dict_keys(['name', 'age', 'hobbies'])  获取字典所有的键 看成列表即可
print(dic.values())  # dict_values(['jason', 18, ['play game', 'basketball']])  获取字典所有的值 看成列表即可
print(dic.items())  # dict_items([('name', 'jason'), ('age', 18), ('hobbies', ['play game', 'basketball'])])
# 获取字典里面所有的键值对 组织成列表套元组的形式 元组内有两个元素 第一个是k第二个是v

　　8.字典了解：

　　　　1.更新字典 .update()

　　　　　　键存在则修改不存在则创建

dic = {
        'name': 'jason',
        'age': 18,
        'hobbies': ['play game', 'basketball']
        }
dic.update({'name': 'jasonNB', 'pwd': 123})
print(dic)

　　　　2.初始化字典 .fromkeys()

print(dict.fromkeys(['k1', 'k2', 'k3'], []))
'''笔试题'''
res = dict.fromkeys(['k1', 'k2', 'k3'], [])
res['k1'].append(111)
res['k2'].append(222)
res['k3'].append(333)

res['k1'] = [111,222,333]
res['k1'].append(444)
print(res)

　　　　3. .setdefault

　　　　　　当键存在的情况下不修改而是获取该键对应的值

　　　　　　当键不存在的情况下新增一组键值对并且该方法的结果是新增的值

print(dic.setdefault('name', 'jasonNB'))
print(dic)
# 当键不存在的情况下 新增一组键值对 并且该方法的结果是新增的值
print(dic.setdefault('pwd', '123'))
print(dic)

元组tuple

　　1.元组第一道笔试题

　　　　元组哪怕内部只有一个元素也需要加上逗号

t1 = (111)  # 整型
t2 = (11.11)  # 浮点型
t3 = ('hello')  # 字符串
'''元组哪怕内部只有一个元素 也需要加上逗号'''
print(type((111,)))
'''容器类型:内部可以存放多个值的数据类型都可以称之为容器类型
    建议:所有的容器类型在存储数据的时候 如果内部只有一个元素 
        那么也推荐你加上逗号

　　2.索引取值

t = (111, 222, 333, 444, 555)
print(t[2])
print(t[-1])

　　3.切片操作

t = (111, 222, 333, 444, 555)
print(t[1:5])
print(t[1:])
print(t[:])

　　4.步长

t = (111, 222, 333, 444, 555)
print(t[1:5:2])

　　5.统计元组内元素的个数len()

t = (111, 222, 333, 444, 555)
print(len(t))  # 5

　　6.for循环

t = (111, 222, 333, 444, 555)
for i in t:
    print(i)

　　7.计数.count()

t = (111, 222, 333, 444, 555)
print(t.count(111))  # 1

　　8.'''笔试题'''

t1 = (111, 222, [11, 22, 33])
t1[2].append(44)
print(t1)

集合set

　　1.定义空集合需要使用关键字set()

s1 = set()

　　2.类型转换

　　　　能够支持for循环的数据类型都可以转成集合(元素要是不可变类型)
　　　　

　　　　'''集合内元素是无序的'''

　　3.去重

s1 = {1, 2, 2, 2, 3, 4, 3, 4, 3, 1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3}
print(s1)  # {1, 2, 3, 4}
name_list = ['kevin', 'jason', 'jason', 'jason', 'kevin', 'kevin']
# 1.先将列表转换成集合
s1 = set(name_list)
# 2.再将去重之后的集合转换成列表
l1 = list(s1)
print(l1)

　　4.练习题

ll = [33, 22, 11, 22, 11, 44, 33, 22, 55, 66, 77, 77, 66, 55, 44]
# 基本要求:去重即可
s1 = set(ll)
ll1 = list(s1)
print(ll1)

# 拔高要求:去重并保留原来的顺序
# 1.先定义一个新列表
new_list = []
# 2.for循环ll列表
for i in ll:
   # 3.判断当前元素是否在新列表中
   if i not in new_list:
       # 3.1 如果不在 则添加到新列表
       new_list.append(i)
# 3.2 如果在 则不管
print(new_list)

　　5.关系运算

　　　　"""两个群体之间做差异比较共同好友共同关注..."""

friends1 = {"zero", "kevin", "jason", "eg"}  # 用户1的好友们
friends2 = {"Jy", "ricky", "jason", "eg"}  # 用户2的好友们
# 1.求两个用户的共同好友
print(friends1 & friends2)  # {'jason', 'eg'}
# 2.求两个用户所有的好友
print(friends1 | friends2)  # {'kevin', 'ricky', 'jason', 'zero', 'Jy', 'eg'}
# 3.求用户1独有的好友
print(friends1 - friends2)  # {'zero', 'kevin'}
# 4.求用户2独有的好友
print(friends2 - friends1)  # {'ricky', 'Jy'}
# 5.求用户1和用户2各自的好友
print(friends1 ^ friends2)  # {'Jy', 'zero', 'kevin', 'ricky'}
# 6.父集与子集
s1 = {11, 22, 33, 44}
s2 = {11, 33}
print(s1 > s2)  # 判断s1是否是s2的父集   True
print(s2 < s1)  # 判断s2是否是s1的子集   True

END

posted @ 2021-11-08 19:45 Snails蜗牛阅读(85) 评论(0) 编辑收藏举报

刷新页面返回顶部

Snails蜗牛

内置方法

数据类型的内置方法

整型int

1.类型转化 int()

2.进制转化

浮点型float

类型转化 float()

字符串str

1.类型转化 str()

2.索引取值 变量名[]

3.索引支持负数 变量名[-1]

4.切片操作 顾头不顾尾 变量名[1:4]

5.步长操作 变量名[1:10:2]

6.统计字符串内部字符的个数 len()

7.移除字符串首尾指定的字符 .strip()

8.按照指定的字符切割字符串 .split()

9.大小写 .upper()转大写 .lower()转小写 .isupper()判断是否大写 .islower()判断是否小写

10.判断字符串是否以指定的字符开头 .startswith()开始 .endswith()结尾

11.格式化输出 .format()

12.字符串的拼接 .join()

13.替换字符串中指定的字符 .replace()

14.判断字符串中是否是纯数字 .isdigit()

字体格式相关

列表list

1.类型转化 list()

2.修改值 列表名[索引] = 修改后的变量值

3.添加值 .append() .insert() .extend()

4.删除值 del 列表名[索引值] .remove() .pop()

5.排序 .sort()

6.顺序颠倒 .reverse()

7.切片

8.列表比较

9.引申出字符串比较

字典dict

1.按k取值 k不存在会直接报错

2.按k修改值 新增键值对(使用频率最高)

3.统计字典内部键值对的个数 len()

4.成员运算 默认只暴露k

5.删除元素 del 字典名['k值'] .pop() .popitem()

6.获取v值 .get()

7.keys() values() items()

8.字典了解：

1.更新字典 .update()

2.初始化字典 .fromkeys()

3. .setdefault

当键存在的情况下 不修改而是获取该键对应的值

元组tuple

1.元组第一道笔试题

2.索引取值

3.切片操作

4.步长

5.统计元组内元素的个数len()

6.for循环

7.计数.count()

8.'''笔试题'''

集合set

1.定义空集合需要使用关键字set()

2.类型转换

3.去重

4.练习题

5.关系运算

END

公告

　　1.类型转化 int()

　　2.进制转化

　　类型转化 float()

　　1.类型转化 str()

　　2.索引取值变量名[]

　　3.索引支持负数变量名[-1]

　　4.切片操作顾头不顾尾变量名[1:4]

　　5.步长操作变量名[1:10:2]

　　6.统计字符串内部字符的个数 len()

　　7.移除字符串首尾指定的字符 .strip()

　　8.按照指定的字符切割字符串 .split()

　　9.大小写 .upper()转大写 .lower()转小写 .isupper()判断是否大写 .islower()判断是否小写

　　10.判断字符串是否以指定的字符开头 .startswith()开始 .endswith()结尾

　　11.格式化输出 .format()

　　12.字符串的拼接 .join()

　　13.替换字符串中指定的字符 .replace()

　　14.判断字符串中是否是纯数字 .isdigit()

　　字体格式相关

　　1.类型转化 list()

　　2.修改值列表名[索引] = 修改后的变量值

　　3.添加值 .append() .insert() .extend()

　　4.删除值 del 列表名[索引值] .remove() .pop()

　　5.排序 .sort()

　　6.顺序颠倒 .reverse()

　　7.切片

　　8.列表比较

　　9.引申出字符串比较

　　1.按k取值 k不存在会直接报错

　　2.按k修改值新增键值对(使用频率最高)

　　3.统计字典内部键值对的个数 len()

　　4.成员运算默认只暴露k

　　5.删除元素 del 字典名['k值'] .pop() .popitem()

　　6.获取v值 .get()

　　7.keys() values() items()

　　8.字典了解：

　　　　1.更新字典 .update()

　　　　2.初始化字典 .fromkeys()

　　　　3. .setdefault

　　　　　　当键存在的情况下不修改而是获取该键对应的值

　　1.元组第一道笔试题

　　2.索引取值

　　3.切片操作

　　4.步长

　　5.统计元组内元素的个数len()

　　6.for循环

　　7.计数.count()

　　8.'''笔试题'''

　　1.定义空集合需要使用关键字set()

　　2.类型转换

　　3.去重

　　4.练习题

　　5.关系运算