python常用内置方法

可变与不可变

如果值改变，内存地址不变，证明就是可变类型
如果值改变，内存地址改变，证明是不可变类中
#不可变类型
x = 10 
print(id(10))
x= 11
print(id(11))

#可变类型
l= [111,222,333]
print(id(l))
l[0] =666
print(id(l))

各种数据类型的内置方法

数字类型

int

1、用途：

​记录年龄等

2、定义方式

age = 18 #其实是定义了age = int(18)
print(type(age))

#int数据类型转换
res = int("   18  ")
print(res,type(res))

​ 名字+括号的意思就是调用某个功能，比如

​ print(…)调用打印功能

​ int(…)调用创建整型数据的功能

​ float(…)调用创建浮点型数据的功能

3、常用操作和内置方法
(算数运算+比较运算)
#存一个值，不可变

float

1、用途：

​ 记录薪资，身高等

2、定义方式

salary = 163.6  #其实是定义了salary =folat(163.6)

3、常用操作和内置方法
(算数运算+比较运算)
存一个值，不可变

字符串类型

1、用途：姓名，性别等

2、定义方式：存一个值 有序，不可变

name = "egon"  # name = str("egon")
# str数据类型转换：可以把任意类型都转换成字符串类型
res = str([1,2,3])
print(res,type(res))  # "[1,2,3]"

3、常用操作+内置的方法

​ 3.1 优先掌握的操作：

(1)、按索引取值(正向取+反向取) ：只能取

msg = 'hello world'
print(msg[4])
print(msg[5])
print(msg[-1])

msg[0] = "H"

(2)、切片(顾头不顾尾，步长)：

从一个大字符串中拷贝出一个子字符串

msg = 'hello world'
res = msg[1:5:2]  # 1 3
res = msg[1:5]  # 1234
res = msg[1:]  #
res = msg[:]  #
res = msg[-1:-4:-1]  # -1 -2 -3
res = msg[-1::-1]  # -1 -2 -3
res = msg[::-1]  # 将字符串颠倒

print(res)
print(msg)

(3)、长度len

msg = 'hello world'
print(len(msg))

(4)、成员运算in和not in

msg = 'hello world'
print('el' in msg)
print('el' not in msg)  # 推荐
print(not 'el' in msg)

(5)、移除空白strip和replace

#strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。
#注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。
name = '       eg on       '
print(name.strip())

msg = "*(&%&%&_+)**&^e*gon*)(^%$$&$"
print(msg.strip('*()&%_+^%$'))

#replace：方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次
x = 'a c d e'
print(x.replace(' ','',1))
print(x.replace(' ',''))

name = '*****eg on****'
print(name.strip('*').replace(" ",''))

# 案例：
inp_user = input("username>>>: ").strip()  # inp_user = "      egon"
inp_pwd = input("password>>>: ").strip()
if inp_user == "egon" and inp_pwd == '123':
    print('ok')
else:
    print('no')

(6)、切分split：

​ 把一个字符串按照某种分割符切分一个列表

msg = "egon:18:male:10"
res = msg.split(':')
print(res)
print(res[0])

res = msg.split(':',1)
print(res)


# 6.1 把列表中的元素按照某种分隔符拼接成字符串
info = ['egon', '18', 'male', '10']

msg = ":".join(info)
print(msg)

(7)、循环

msg = "hello world"
for i in msg:
    print(i)

需要掌握的操作（****）

1、strip,lstrip,rstrip

# 
print("******egon*****".strip('*')) #去除所有**
print("******egon*****".lstrip('*'))#去除左边的**
print("******egon*****".rstrip('*'))#去除右边的**

2、lower,upper

print("AbC".lower())	#字符串全小写
print("AbC".upper())	#字符串全大写

3、startswith,endswith

startswith:用于检测字符串是否以指定的前缀开始。

endswith:用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。

print('hello world'.startswith('he'))
print('hello world'.endswith('d'))

print('hello world'.startswith('h'))
print('hello world'.startswith('e',1,4))

4、format的三种玩法

格式化函数

式化字符串的函数 str.format()，它增强了字符串格式化的功能。

基本语法是通过 {} 和 : 来代替以前的 % 。

format 函数可以接受不限个参数，位置可以不按顺序。

print("my name is %s my age is %s" % ('egon', 18))
print("my name is {name} my age is {age}".format(age=18,name='egon'))

print("my name is {} my age is {}".format(18,'egon'))
print("my name is {1} my age is {0}{0}{0}".format(18,'egon'))


x = 'egon'
y = 18
print(f'my name is {x} ,my age is {y}')

5、split,rsplit,replace

strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。
#注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。

rsplit() 方法从右侧开始将字符串拆分为列表。

msg = 'egon:18:male'
print(msg.split(':',1))
print(msg.rsplit(':',1))

x = 'a c d e'
print(x.replace(' ','',1))
print(x.replace(' ',''))

6、join

​ join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

str = "-";
seq = ("a", "b", "c"); # 字符串序列
print str.join( seq );

#a-b-c

7、isdigit

​ 检测字符串是否只由数字组成。

print("18".isdigit())

练习

age = input('>>>: ').replace(' ', '')
if age.isdigit():
    age = int(age)
    if age > 18:
        print('too big')
    elif age < 18:
        print('too small')
    else:
        print('you got it')
else:
    print("必须输入数字，小垃圾")

需要的了解的操作（***）

1、find,rfind,index,rindex,count 查找

msg = 'hello egon ahahah egon xxx egon'
print(msg.find('egon1'))
print(msg.index('egon1'))
print(msg.rfind('egon'))

2、center,ljust,rjust,zfill 定义字体位置

print('egon'.center(50,'*'))
print('egon'.ljust(50,'*'))
print('egon'.rjust(50,'*'))

print('egon'.rjust(50,'0'))
print('egon'.zfill(50))

#***********************egon***********************
#egon**********************************************
#**********************************************egon
#0000000000000000000000000000000000000000000000egon
#0000000000000000000000000000000000000000000000egon

3、captalize,swapcase,title

​ captalize ：将字符串的第一个字母变成大写,其他字母变小写

​ swapcase：用于对字符串的大小写字母进行转换。

​ title：首字母全部大写

print('abcd'.capitalize())  
print('AbCd'.swapcase())
print('my name is egon'.title())

#Abcd
#aBcD
#My Name Is Egon

4、is数字系列

isdigit():方法检测字符串是否只由数字组成。

isnumeric():方法检测字符串是否只由数字组成。这种方法是只针对unicode对象。

print('18'.isdigit())
print('Ⅳ'.isnumeric())

#True
#True

5、is其他

name='egon'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成

print(name.islower())#检测字符串是否由小写字母组成。
print(name.isupper()) #方法检测字符串中所有的字母是否都为大写。

name=' '
print(name.isspace()) #检测字符串是否只由空格组成。

name = 'My Is Egon'
print(name.istitle())  #检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。

列表类型

1、定义：

​ 在[]内,用逗号分隔开多个任意数据类型的值。可以存多个值，且有序可变

l1 = [1,'a',[1,2]]  # 本质:l1 = list([1,'a',[1,2]])

2、类型转换

但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型，list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中

list('wdad') # 结果：['w', 'd', 'a', 'd'] 
list([1,2,3]) # 结果：[1, 2, 3]
list({"name":"jason","age":18}) #结果：['name', 'age']
list((1,2,3)) # 结果：[1, 2, 3] 
list({1,2,3,4}) # 结果：[1, 2, 3, 4]

3、常用操作+内置的方法

(1)、按索引存取值(正向存取+反向存取)：即可存也可以取

l = [111,222,333,444,555,666,777]
print(l[0])
print(l[-1])
print(id(l))
l[0] = 999
print(id(l))

l[7] = 888  # 如果索引不存在则报错

2、切片(顾头不顾尾，步长)

l = [111,222,333,444,555,666,777]
print(l[1:4:1])  # 拷贝

print(l[:])
print(l[::-1])

3、长度

l = [111,222,333,444,555,666,777]
print(len(l))

4、成员运算in和not in

l = [111,222,333,444,555,666,777]
print(333 in l)

5、追加、插入

l = [111,222,333,444,555,666,777]
l.append(888)

l.insert(3,999999999999)
print(l)

6、删除

# （1）万能删除
del l[1]
print(l)

# (2) l.remove()
v = l.remove(333)
print(l)
print(v)

# (3) l.pop()
v = l.pop(2)
print(l)
print(v)

7、循环

l = [111,222,333,444,555,666,777]
for i in l:
    print(i)

掌握练习

l = [111,222,333,444,333,555,666,777]
print(l.index(333))
print(l.index(9999))

print(l.count(333))

l = [111,'a',333,'dddd']
l.reverse()
print(l)

l = [111,'a',333,'dddd']
l = [111, -3, 99, 27]
l.sort(reverse=True)
print(l)

l = [111, -3, 99, 27]
nums = [333,444,555]
# l.append(nums)
l.extend(nums)
print(l)



print(len(l))  # l.__len__()

new_l = l.copy()
new_l = l[:]

元组

​ 1、用途：元组就是一种不可变的列表,存多个值，有序且不可变

​ 2、定义方式：在()内用逗号分割开多个任意类型的元素

t = (11,11.333,"aaa",[666,777])  # t = tuple()
print(type(t))

t[0] = 999

t = (1111,)
print(type(t))

# tuple数据类型转换
print(tuple("hello"))

3、常用操作+内置的方法
优先掌握的操作：
1、按索引取值(正向取+反向取)：只能取
2、切片(顾头不顾尾，步长)
3、长度
4、成员运算in和not in

t = (111,222,222,222,333)
print(t.count(222))
print(t.index(222))

字典

1、用途：用于存放多个值，有序，一种可变容器模型，且可存储任意类型对象

2、定义方式：字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中，其中value可以是任意类型，而key必须是不可变类型，通常是字符串类型

dic = {1:111111,33.33:"aaa",(1,2,3):'bbbb'}  # dic =  dict(...)
print(dic[(1,2,3)]) 	#bbbb


#dict数据类型转换
dic = dict([('name'='egon','age'=18,'gender'='male')])#列表类型转换为字典类型
print(dic)		#{'name': 'egon', 'age': 18}

3、常用操作+内置方法

1、按key存取值：

​ 可存可取

dic = {'name': 'egon', 'age': 18}
print(dic['name'])
print(dic['name1']) #不存在的会报错，

print(dic.get('name'))
print(dic.get('name1')) #不存在的会报错，

dic['gender'] = 'male'
print(dic)

dic = {'name': 'egon', 'age': 18,'name':"tom",'name':'lili'}
print(dic)

2、长度len

dic = {'name': 'egon', 'age': 18}
print(len(dic))

3、成员运算in和not in

dic = {'name': 'egon', 'age': 18}
print('name' in dic)

4、删除

# 万能删除
del dic['name']
print(dic)

dic.pop()
v = dic.pop('name')
print(v)

dic.popitem()
res = dic.popitem()
print(res)

5、键keys()，值values()，键值对items()

"""
>>> dic = {'name': 'egon', 'age': 18}
>>>
>>>
>>> dic.keys()
['age', 'name']
>>>
>>> dic.values()
[18, 'egon']
>>>
>>> dic.items()
[('age', 18), ('name', 'egon')]
"""

6、循环

dic = {'name': 'egon', 'age': 18}
for k in dic.keys():
    print(k)

for k in dic:
    print(k)

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

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

​ 需要掌握的操作

• update:函数把字典dic的键/值对更新到dict里。

• setdefault() 函数:和 get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。

• fromkeys:函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。

  ​ dict.fromkeys(seq[, value])

dic = {'name': 'egon', 'age': 18}
dic.update({'name': "EGON", 'gender': "male"})
print(dic)

dic = {'name': 'egon', 'age': 18,'level':100}
# 如果level这个key存在于字典中，则什么都不做
# 否则就往字典中添加一组键值对'level':10

# if 'level' in dic:
#     pass
# else:
#     dic['level'] = 10

v = dic.setdefault('level',10)


# print(dic)
print(v)

###################################
l = ['name', 'age', 'gender']

dic = {}
for x in l:
    dic[x] = None

#dic = {}.fromkeys(l,None)
dic = {}.fromkeys(l,[])
dic['name'].append(111)
print(dic)

练习

nums = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]

dic = {'k1': [], 'k2': []}

for num in nums:
    if num > 66:
        dic['k2'].append(num)
    else:
        dic['k1'].append(num)

print(dic)

集合

1、用途：

​ 集合、list、tuple、dict一样都可以存放多个值，无序，可变，但是集合主要用于：去重、关系运算

2、定义：

​ 在{}内用逗号分隔开多个元素，集合具备以下三个特点：
​ 1：每个元素必须是不可变类型
2：集合内没有重复的元素
3：集合内元素无序

# 注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。

# 注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，现在我们想定义一个空字典和空集合，该如何准确去定义两者?
d = {} # 默认是空字典 
s = set() # 这才是定义空集合


s = {111,33.333,(1,2,3),111,111,111,111}  # s=set(...)
print(s)



#set类型转换
print(set('hello'))
print(set([(1,2,3),[1,2,3,4,5],(1,2,3)]))

3、常用操作+内置方法

1、长度len

s = {1,2,3}
print(len(s))

2、成员运算in和not in

s = {1,2,3}
print(1 in s)

pythons = {'张三', '李四', '王五', '刘6', 'egon', 'lili', '李建国'}
linuxs = {'铁蛋', '铜蛋', '钢弹', 'egon', '狗蛋', 'lili'}

3、|合集

​ 求所有的同学姓名

print(pythons | linuxs)
print(pythons.union(linuxs))

4、&交集:

​ 同时报名两门课程的同学

print(pythons & linuxs)
print(pythons.intersection(linuxs))

pythons = pythons & linuxs
pythons.intersection_update(linuxs)

5、-差集:

​ 求只报名了python课程的同学

print(pythons - linuxs)
print(pythons.difference(linuxs))
pythons.difference_update(linuxs)

print(linuxs - pythons)

6、^对称差集

​ 求没有同时报名两门课程的同学

s = (pythons - linuxs) | (linuxs - pythons)
s = pythons ^ linuxs
print(s)

s = pythons.symmetric_difference(linuxs)
print(s)

7、==

s1 = {1,2,3}
s2 = {3,1,2}
print(s1 == s2)

8、父集：>=,子集：<=

s1 = {1,2,3}
s2 = {1,2}
# s2 = {1,2,4}
print(s1 >= s2)

#issuperset() 方法用于判断指定集合的所有元素是否都包含在原始的集合中，如果是则返回 True，否则返回 False。
print(s1.issuperset(s2))

print(s2 <= s1)
#issubset() 方法用于判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False。
print(s2.issubset(s1))

# 需要掌握
s1 = {1, 2, 3}
# s1.update({3,4,5,6})
# res = s1.pop()

# s1.remove(22222)
# print(s1)

s1.discard(2222222) #discard() ：方法用于移除指定的集合元素。
print(s1)

# s1.add(4)
# print(s1)

s2 = {3, 4, 5, 6}

print(s1.isdisjoint(s2))  
#isdisjoint() ：用于判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。