整型内置方法

定义

int() 函数将一个字符串或数字转换为整型

语法

class int(x, base=10)
# x --字符串或数字
# base --进制数,默认十进制

类型转换

a = int('1')
print(a, type(a))
# 1 <class 'int'>

补充:

将十进制转换成其他机制

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

浮点型内置方法

定义

float()函数用于将整数和字符串转换成浮点数。

语法

class float([x])
# x --整数或字符串

类型转换

a = float('1.1')
b = float('1')
print(a, b, type(a), type(b))
# 1.1 1.0 <class 'float'> <class 'float'>

字符串内置方法(常用)

定义

str()函数可以转换所有基本数据类型

语法

class str(object='')
#  object --对象

类型转换

a = str(1)
b = str(1.1)
c = str([1, 2, 3])
d = str({'name': 'kevin'})
e = str((1, 2, 3))
f = str({1, 2, 3})
print(a, type(a), '\n', b, type(b), '\n', c, type(c), '\n', d, type(d), '\n', e, type(e), '\n', f, type(f))
#  1 <class 'str'> 
#  1.1 <class 'str'> 
#  [1, 2, 3] <class 'str'> 
#  {'name': 'kevin'} <class 'str'> 
#  (1, 2, 3) <class 'str'> 
#  {1, 2, 3} <class 'str'>

基本操作

索引取值

使用

s = "hello world"
print(s[0])
# h

切片操作

使用

s = "hello world"
print(s[2:4])  # 从索引2(包含2)取到索引4(不包含4)
# ll
print(s[2:9:2])  # 从索引2开始(包含2)取到索引9(不包含9),步长为2(默认是1)
# llowr

统计字符串中字符的个数

定义

len() 函数返回对象(字符、列表、元组等)长度或个数

语法

len( s )
# s --对象

使用

s = "hello world"
print(len(s))
# 11 (其中空格也算字符)

成员运算

定义

in 判断是否存在,返回TrueFalse

使用

s = "hello world"
print('ll' in s)
# True

移除字符串指定的字符(频率高)

定义

strip() 去除首尾匹配的字符,默认空格

lstrip() 去除左侧匹配的字符,默认空格

rstrip() 去除右侧匹配的字符,默认空格

语法

str.strip([chars])
# chars --移除字符串头尾指定的字符序列

使用

s = "   hello   "
print(s.strip())  # 默认移除字符串首尾的空格
# hello
s = "%%%hell%o%%%"
print(s.strip('%'))
# hell%o
print(s.lstrip('%'))
# hell%o%%%
print(s.rstrip('%'))
# %%%hell%o

按照指定的字符切割字符串

定义

split() 从左开始切割匹配的字符,返回列表

rsplit() 从右开始切割匹配的字符,返回列表

语法

str.split(str="", num=string.count(str))
# str --分隔符,默认为所有的空字符,包括空格、换行(\n)、制表符(\t)等
# num --分割次数,默认为 -1, 即分隔所有

使用

data = 'kevin|male|22'
print(data.split('|')) 
# ['kevin', 'male', '22']
name, gender, age = data.split('|')  # 解压赋值
print(name, gender, age)
# kevin male 22
print(data.split('|', maxsplit=1))  # maxsplit代表切割几次
# ['kevin', 'male|22']
print(data.rsplit('|', maxsplit=1))  # 从右开始切割
# ['kevin|male', '22']

指定字符串进行大小写转换(常用验证码)

定义

lower() 将字符串的里的所有英文字母转换为小写

upper() 将字符串的里的所有英文字母转换为大写

islower() 判断字符串里的所有英文字母,是否为小写

issuper() 判断字符串里的所有英文字母,是否为大写

语法

str.lower()
str.upper()
str.islower()
str.isupper()
# str --检测的字符串

使用

s1 = 'KEVIN123'
s2 = 'kevin123'
print(s1.lower())
# kevin123
print(s2.upper())
# KEVIN123
print(s1.islower())
# False
print(s2.isupper())
# False

判断字符串的首尾指定字符

定义

startswith 判断字符串的开头是否为指定字符

endswish 判断字符串的结尾是否为指定字符

语法

str.startswith(substr, start, end)
str.endswith(substr, start ,end)
# str --检测的字符串
# substr  --指定的子字符串
# start --可选参数用于设置字符串检测的起始位置
# end --可选参数用于设置字符串检测的结束位置

使用

s = 'kevin'
print(s.startswith('k'))
# True
print(s.endswith('i'))
# False

格式化输出

定义

format() 通过{}来占位,代替%s

使用

# 1.通过 {} 占位符直接输出
print("My name is {} my age is {}".format('kevin', 22))
# My name is kevin my age is 22

# 2.通过索引取值
print("My name is {0} my age is {3}".format('kevin', 'tony', 18, 22))
# My name is kevin my age is 22

# 3.通过“指名道姓”方式取值
print("My name is {name} my age is {age}".format(name='kevin', age=22))
# My name is kevin my age is 22

# 4.直接使用已经出现过的常量(常用)
name = 'kevin'
age = 22
# 要在前面加f!!!
print(f"My name is {name} my age is {age}")
# My name is kevin my age is 22

拼接字符串

使用

s1 = '好好学习'
s2 = '天天向上'
print(s1 + s2)
# 好好学习天天向上
print((s1 + s2 + '\n') * 5)
# 好好学习天天向上
# 好好学习天天向上
# 好好学习天天向上
# 好好学习天天向上
# 好好学习天天向上

替换字符串

定义

join() 将序列中的元素以指定的字符连接生成一个新的字符串

语法

str.join(sequence)
# str --检测的字符串
# sequence --要连接的元素序列

使用

s = 'kevin'
print('|'.join(s))  # 相当于将括号里的元素进行for循环
# k|e|v|i|n
s = '|'
print(s.join(['k', 'e', 'v', 'i', 'n']))
# k|e|v|i|n

补充:join方法相当于是将括号内的元素进行for循环

替换字符串 (常用编辑器替换)

定义

replace() 函数是把字符串中的旧字符串,替换成新字符串,如果指定第三个参数max,则替换不超过 max 次

语法

str.replace(old, new, max)
# old --将被替换的子字符串
# new --新字符串,用于替换old子字符串
# max --可选字符串, 替换不超过 max 次

使用

s = 'tony|tony|tony|tony|tony'
print(s.replace('tony', 'kevin'))
# kevin|kevin|kevin|kevin|kevin
print(s.replace('tony', 'kevin', 2))  # 从左向右替换
# kevin|kevin|tony|tony|tony

补充:很多文本编辑器里面的替换功能 就可以使用replace完成

判断字符串是否为纯整数

定义

isdigit() 判断字符串是否为纯整数

语法

str.isdigit()

使用

s = '1'
print(s.isdigit())
# True
s = '0'
print(s.isdigit())
# True
s = 'kevin'
print(s.isdigit())
# False
s = '-1'
print(s.isdigit())
# False

查找指定字符

定义

find() 检测字符串中是否包含子字符串

语法

str.find(str, start, end)
# str --指定检索的字符串
# start --开始索引,默认为0
# end --结束索引,默认为字符串的长度

使用

s = 'kevin|kevin'
print(s.find('i'))
# 3
print(s.find('n'))
# 4
print(s.find('n', 6, 11))
# 10
print(s.index('o'))  # 使用index()会报错,不推荐使用

改变文本位置

定义

center()指定宽度居中的字符串,可选填充的字符,默认为空格

ljust() 指定宽度向左对齐的字符串,可选填充的字符,默认为空格

rjust() 指定宽度向右对齐的字符串,可选填充的字符,默认为空格

语法

str.center(width, fillchar)
str.ljust(width, fillchar)
str.rjust(width, fillchar)
# width --字符串的总宽度
# fillchar --填充字符

使用

s = 'kevin'
print(s.center(20,'-'))
# -------kevin--------
print(s.ljust(20, '-'))
# kevin---------------
print(s.rjust(20, '-'))
# ---------------kevin

特殊符号

斜杠与一些英文字母组合会产生特殊的含义

使用

print('hello\nkevin')  # \n 表示换行
print('hello\tkevin')  # \t 表示制表符
print('hello\akevin')  # \a 表示特殊符号

# 如果想取消它们的特殊含义 可以在字符串的前面加一个字母r
print(r'hello\nkevin') 
# hello\nkevin

首字母大写

使用

msg = 'hello,my name is kevin'
print(msg.capitalize)
# Hello,my name is kevin

大小写翻转

使用

msg = 'hello,my name is kevin'
print(msg.swapcase())
# HELLO,MY NAME IS KEVIN

每个单词的首字母大写

使用

msg = 'hello,my name is kevin'
print(msg.title())
# Hello,My Name Is Kevin

列表内置方法

定义

list() 用于将 字符串、列表、字典、元组、集合,转换为列表

语法

list( seq )
# seq -- 要转换为列表的字符串、列表、字典、元组、集合

类型转换

print(list(1))
# 报错
print(list(1.1))
# 报错
print(list('kevin'))  # 字符串
# ['k', 'e', 'v', 'i', 'n']
print(list([1, 2, 3]))  # 列表
# [1, 2, 3]
print(list({'name': 'kevin'}))  # 字典
# ['name']
print(list((1, 2, 3,)))  # 元祖
# [1, 2, 3]
print(list({1, 2, 3}))  # 集合
# [1, 2, 3]

基本操作

索引取值

使用

name_list = ['kevin', 'tony', 'jerry']
print(name_list[0])
# kevin
print(name_list[-1])
# jerry

切片操作

使用

name_list = ['kevin', 'tony', 'jerry']
print(name_list[0:4])
# ['kevin', 'tony', 'jerry']
print(name_list[-4:0])
# ['kevin', 'tony']
print(name_list[-1:-4:-1])
# ['jerry', 'tony', 'kevin']

统计列表中元素的个数

使用

name_list = ['kevin', 'tony', 'jerry']
print(len(name_list))
# 3

成员运算

使用

name_list = ['kevin', 'tony', 'jerry']
print('kevin' in name_list)
# True
print('jason' in name_list )
# False

列表添加元素

使用

# 1.尾部追加'单个'元素
name_list = ['kevin', 'tony', 'jerry']
name_list.append('jason')
print(name_list)
# ['kevin', 'tony', 'jerry', 'jason']

# 2.指定位置插入'单个'元素
name_list.insert(2, '插入的元素')
print(name_list)
# ['kevin', 'tony', '插入的元素', 'jerry', 'jason']

# 3.合并列表
name_list.extend([1,2,3])  # extend其实可以看成是for循环+append
print(name_list)
# ['kevin', 'tony', '插入的元素', 'jerry', 'jason', 1, 2, 3]

name_list += [1,2,3]  # 效率不高
print(name_list) 
#['kevin', 'tony', '插入的元素', 'jerry', 'jason', 1, 2, 3, 1, 2, 3]

删除列表元素

使用

# 1. 通用删除方式(没有会报错)
name_list = ['kevin', 'tony', 'jerry']
del name_list[0]
print(name_list)
# ['tony', 'jerry']

# 2."指名道姓"删除
name_list = ['kevin', 'tony', 'jerry']
print(name_list.remove('kevin'))
# None
print(name_list)
# ['tony', 'jerry']

# 3.延迟删除
name_list = ['kevin', 'tony', 'jerry']
print(name_list.pop())
# jerry
print(name_list)
# ['kevin', 'tony']
print(name_list.pop(1))  # 支持索引
# tony
print(name_list)
# ['kevin']

修改列表元素

使用

name_list = ['kevin', 'tony', 'jerry']
print(id(name_list[0]))
# 140594414712680
name_list[0] = 'kevinNB'
print(id(name_list[0]))
# 140594417263368

排序

使用

s = [9, 4, 1, 8, 5, 6, 2, 7, 3]
s.sort()
print(s)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
s.sort(reverse=True)  # 可以修改尾降序
print(s)
# [9, 8, 7, 6, 5, 4, 3, 2, 1]

列表比较运算

使用

s1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
s2 = [11, 22, 33, 44]
print(s1 > s2)  # 列表在做比较的时候 其实比的是对应索引位置上的元素
# False
s1 = ['A', 'B', 'C']  # A对应ASCII是65
s2 = ['a', 'b', 'c']  # a对应ASCII是97
print(s1 > s2)
# False

统计列表中某个元素出现的次数

使用

s = [1, 2, 3, 1, 4, 5, 2, 3, 2, 1, 3, 2, 1, 1, 1, 3, 2, 5, 6, 1, 3]
print(s.count(1))
# 7

清空列表

使用

s = [1, 2, 3, 1, 4, 5, 2, 3, 2, 1, 3, 2, 1, 1, 1, 3, 2, 5, 6, 1, 3]
s.clear()
print(s)
# []

字典内置方法

定义

dict()函数用于创建一个字典

语法

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
# **kwargs -- 关键字。
# mapping -- 元素的容器,映射类型(Mapping Types)是一种关联式的容器类型,它存储了对象与对象之间的映射关系。
# iterable -- 可迭代对象。

类型转换

print(dict(a='a', b='b', c='c'))
# {'a': 'a', 'b': 'b', 'c': 'c'}
print(dict(zip(['one', 'two', 'three'], [1, 2, 3])))  # 映射函数方式来创造字典
# {'oen': 1, 'two': 2, 'three': 3}
print(dict([('one', 1), ('two', 2), ('three', 3)]))
# {'one': 1, 'two': 2, 'three': 3}

# 取值方法

# 1.按key值取(不推荐)
d = {'name': 'kevin', 'age': '22', 'hobby': ['run', 'cs']}
print(d['name'])
# kevin
print(d[xxx])  # 报错

基本操作

取值方法

使用

# get() 取值(推荐)
# dict.get(key[, value]) 
# key -- 字典中要查找的键。
# value -- 可选,如果指定键的值不存在时,返回该默认值
print(d.get('name'))
# kevin
print(d.get('xxx'))
# None
print(d.get('xxx', '这个键值不存在,可以是任何数据类型'))
# 这个键值不存在,可以是任何数据类

修改值

使用

d = {'name': 'kevin', 'age': '22', 'hobby': ['run', 'cs']}

print(d['name'], id(d))
# kevin 140553714244056
d['name'] = 'kevin666'
print(d['name'], id(d))
# kevin666 140553714244056

添加键值对

使用

d = {'name': 'kevin', 'age': '22', 'hobby': ['run', 'cs']}

d['pwd'] = 123  # 键不存在则是新增一个键值对
print(d)
# {'name': 'kevin', 'age': '22', 'hobby': ['run', 'cs'], 'pwd': 123}

成员运算(只能判断key)

使用

d = {'name': 'kevin', 'age': '22', 'hobby': ['run', 'cs']}

print('name' in d)
# True
print('kevin' in d)
# False

删除键值对

使用

d = {'name': 'kevin', 'age': '22', 'hobby': ['run', 'cs']}

del d['hobby']
print d
# {'name': 'kevin', 'age': '22'}

print(d.pop('age'))
# 22
print(d)
# {'name': 'kevin'}

d.popitem() # 随机弹出一个(使用频率很低 可以忽略)

获取所有键、值、和键值对

使用

d = {'name': 'kevin', 'age': '22', 'hobby': ['run', 'cs']}

print(d.keys())
# dict_keys(['name', 'age', 'hobby'])
print(d.values())
# dict_values(['kevin', '22', ['run', 'cs']])
print(d.items())  # 可以看成列表套元组
# dict_items([('name', 'kevin'), ('age', '22'), ('hobby', ['run', 'cs'])]

for i in d.values():
    print(i)

补充:在python2中上述三个方法就是直接返回一个列表

更新字典

使用

d = {'name': 'kevin', 'age': '22', 'hobby': ['run', 'cs']}
d.update({'name': 'tony', 'k4': 'xxx'})
print(d)  #  键存在则修改 键不存在则新增
# {'name': 'tony', 'age': '22', 'hobby': ['run', 'cs'], 'k4': 'xxx'}

快速生成字典

使用

d = dict.fromkeys(['name', 'age', 'hobby'], [])
print(d)
# {'name': [], 'age': [], 'hobby': []}

更多操作

setdefault() 如果键不存在于字典中,将会添加键并将值设为默认值

语法

dict.setdefault(key, default=None)
# key -- 查找的键值
# default -- 键不存在时,设置的默认键值

使用

d = {'name': 'kevin', 'age': '22', 'hobby': ['run', 'cs']}
print(d.setdefault('xxx', 'xxx')) # # 键不存在则新增键值对 并且有返回结果是新增的value
# xxx
print(d)  
# {'name': 'kevin', 'age': '22', 'hobby': ['run', 'cs'], 'xxx': 'xxx'}

print(d.setdefault('name', 'tony'))  # 键存在 则返回对应的值 但不做修改
# kevin
print(d)
# {'name': 'kevin', 'age': '22', 'hobby': ['run', 'cs'], 'xxx': 'xxx'}

笔试题

d = dict.fromkeys(['name', 'age', 'hobby'], [])
print(d)
# {'name': [], 'age': [], 'hobby': []}
d['name'].append(123)
print(d)
# {'name': [123], 'age': [123], 'hobby': [123]}

元组内置方法

定义

tuple 函数将可迭代系列(如列表)转换为元组

语法

tuple(iterable)
# iterable -- 要转换为元组的可迭代序列。

类型转换

print(tuple(1))  #报错
print(tuple(1.1))  # 报错
print(tuple('kevin'))
# ('k', 'e', 'v', 'i', 'n')
print(tuple([1, 2, 3]))
# (1, 2, 3)
print(tuple({'name': 'kevin'}))
# ('name',)
print(tuple({1, 2, 3}))
# (1, 2, 3)

特性

t = (1, 1.11, 'kevin')
print(type(t))
# <class 'tuple'>
t = (1)
print(type(t))
# <class 'int'>
t = (1.11)
print(type(t))
# <class 'float'>
t =('kevin')
print(type(t))
# <class 'str'>

知识点:当元组内只有一个元素的时候 一定要在元素的后面加上逗号 a = (1,2,3,)。一般情况下 我们会习惯性的将所有可以存储多个数据的类型的数据,如果内部只有一个元素 也会加逗号。

t = (1,)
print(type(t))
# <class 'tuple'>
t = (1.11,)
print(type(t))
# <class 'tuple'>
t =('kevin',)
print(type(t))
# <class 'tuple'>

基本操作

索引取值

使用

t = (1, 2, 3)
print(t[0])
# 1

切片操作

使用

t = (1, 2, 3, 4, 5, 6, 7, 8)
print(t[2:5:2])
# (3, 5)

统计元素个数

使用

t = (1, 2, 3, 4, 5, 6, 7, 8)
print(len(t))
# 8

成员运算

使用

t = (1, 2, 3, 4, 5, 6, 7, 8, 3, 3)
print(2 in t)
# True
print(9 in t)
# False

某元素统计出现次数

使用

t = (1, 2, 3, 4, 5, 6, 7, 8, 3, 3)
print(t.count(3))
# 3

补充:元组内元素不能"修改": 元组内各个索引值指向的内存地址不能修改

笔试题

t = (1, 2, 3, 4, [1, 2])
print(id(t[-1]))
# 140252689809480
t[-1].append('kevin')
print(t)
# (1, 2, 3, 4, [1, 2, 'kevin'])
print(id(t[-1]))
# 140252689809480

集合内置方法

定义

set() 函数创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等

语法

class set([iterable])
# iterable -- 可迭代对象对象

类型转换

# print(set(11))  # 报错
# print(set(11.11))  # 报错
print(set('kevin'))
# {'k', 'e', 'v', 'n', 'i'}
print(set([11, 22, 33, 44]))
# {33, 11, 44, 22}
print(set({'name': 'kevin'}))
# {'name'}
print(set((11, 22, 33)))
# {33, 11, 22}
# print(set(True))  # 报错

基本操作

去重

集合内出现重复的元素,会被集合自动去重(自带去重特性)但是是输出无序的

s = set('kevinkevinkevinkevin')
print(s)
# {'e', 'v', 'n', 'i', 'k'}

关系运算

判断两个群体内的差异

s1 = {'jason', 'kevin', 'tony', 'jerry'}
s2 = {'jason', 'tom', 'jerry', 'jack'}
print(s1 & s2)  # 交集
# {'jason', 'jerry'}
print(s1 - s2)  # 差集
# {'tony', 'kevin'}
print(s1 | s2)  # 并集
# {'tony', 'jason', 'jerry', 'kevin', 'tom', 'jack'}
print(s1 ^ s2)  # 补集
# {'tony', 'kevin', 'tom', 'jack'}

可变类型与不可变类型

可变类型

值发生改变时,内存地址不变,修改的是本身

list(列表)、dict(字典),set(集合),是可变类型

可变类型

不可变类型

值发生改变时,内存地址也发生改变,在改变原值,是产生了新的值

数值型(int、string、bool)、string(字符串)、tuple(元组)都是不可变类型

不可变类型

队列与堆栈

队列

先进先出

new_list = []
# 先进
new_list.append(1)
new_list.append(2)
new_list.append(3)
# 先出
print(new_list.pop(0))
# 1
print(new_list.pop(0))
# 2
print(new_list.pop(0))
# 3

堆栈

先进后出

new_list = []
# 先进
new_list.append(1)
new_list.append(2)
new_list.append(3)
# 后出
print(new_list.pop())
# 3
print(new_list.pop())
# 2
print(new_list.pop())
# 1

垃圾回收机制

引用计数

python会将引用计数为0的数据清除

name = 'kevin'  # kevin引用计数为1
a = name        # kevin引用计数为2
# 内存中数据身上绑定的变量名的个数
# ps:还可以了解一下循环引用的情况

标记清除

当内存空间即将满了的时候 python会自动启动应急机制,停止程序的运行 依次检查值的引用计数,并给计数为0的数据打上标记,然后一次性清理掉

分代回收

根据值存在的时间长短 将值划分为三个等级(1,2,3)

等级1 检测机制每隔5s来一次
等级2 检测机制每隔1min来一次
等级3 检测机制每隔5min来一次

Last modification:June 15, 2022
如果觉得我的文章对你有用,请随意赞赏