字符串的内置方法

数据类型内置方法

# 方法   名字()

1. 整型
# 进制转换
print(bin(10))  # 0b1010
print(oct(10))  # 0o12
print(hex(10))  # 0xa

# 记忆：0b代表二进制  0o代表八进制  0x代表十六进制

print(int('0b1010', 2))
print(int('0o12', 8))
print(int('0xa', 16))
2. 
# float同样可以用来做数据类型的转换
>>> s = '12.3'
>>> res=float(s)
>>> res,type(res)
(12.3, <class 'float'>)

字符串的内置方法(优先掌握)

# 1. 把其他数据类型转为字符串
print(str(19))
print(str(19.1))
print(str([1, 2, 3, 4]))
print(str({'username':'kecin', 'age':18}))
print(str((1,2,3,4)))
print(str(True))
print(str({11,22,33}))


# 1.按索引取值(正向取，反向取)：
# 1.1 正向取(从左往右)
>>> str1[6]
p
# 1.2 反向取(负号表示从右往左)
>>> str1[-4]
h
# 1.3 对于str来说，只能按照索引取值，不能改
>>> str1[0]='H' # 报错TypeError


# 2.切片(顾头不顾尾，步长)
# 2.1 顾头不顾尾：取出索引为0到8的所有字符
>>> str1[0:9]  
hello pyt
# 2.2 步长：0:9:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2、4、6、8的字符
>>> str1[0:9:2]  
hlopt 
# 2.3 反向切片
>>> str1[::-1]  # -1表示从右往左依次取值
!nohtyp olleh

# 3.长度len
# 3.1 获取字符串的长度，即字符的个数，但凡存在于引号内的都算作字符)
>>> len(str1) # 空格也算字符
13

# 4.成员运算 in 和 not in	
# 4.1 int:判断hello 是否在 str1里面
>>> 'hello' in str1  
True
# 4.2 not in:判断tony 是否不在 str1里面
>>> 'tony' not in str1 
True

# 5.strip移除字符串首尾指定的字符(默认移除空格)
# 5.1 括号内不指定字符，默认移除首尾空白字符(空格、\n、\t)
>>> str1 = '  life is short!  '
>>> str1.strip()  
life is short!

# 5.2 括号内指定字符，移除首尾指定的字符
>>> str2 = '**tony**'  
>>> str2.strip('*')  
tony

# 6.切分split
#  括号内不指定字符，默认以空格作为切分符号
 > str3='hello world'
 >> str3.split()
 >>> ['hello', 'world']
# 括号内指定分隔字符，则按照括号内指定的字符切割字符串
 > str4 = '127.0.0.1'
 >> str4.split('.')  
 >>> ['127', '0', '0', '1']  # 注意:split切割得到的结果是列表数据类型


# 7.循环
>>> str5 = '今天你好吗？'
>>> for line in str5:  # 依次取出字符串中每一个字符
...     print(line)
...
今
天
你
好
吗
？

字符串的内置方法(需要掌握)

1、大小写：lower(), upper()
> str2 = 'My nAme is tonY！'
>> str2.lower()  # 将英文字符串全部变小写
my name is tony！
>> str2.upper()  # 将英文字符串全部变大写
MY NAME IS TONY！
"""
    图片验证码不区分大小写
        思路：把用户输入的验证码全部转为大写或者小写，跟原来的验证码都转为大写或者小写进行比较
"""
 old_code = 'oldBoY'
 print('返回给你的验证码是：%s' % old_code)
# 用户输入的验证码
 real_code=input('请输入验证码：')
if old_code.lower() == real_code.lower():
if old_code.upper() == real_code.upper():
    print('验证码输入正确')
 else:
     print('验证码错误')


# 补充：
 > res = 'sadWW'
 >> print(res.islower())  # False --> 判断是否是
全小写
 >> print(res.isupper())  # False --> 判断是否是全大写

2.字符的开头与结尾：startswith, endswith
> x = 'boy girl'
# startswith()判断字符串是否以括号内指定的字符开头，结果为布尔值True或False
>> x.startswith('b')
True
>> x.startswith('g')
False
# endswith()判断字符串是否以括号内指定的字符结尾，结果为布尔值True或False
>> x.endswith('girl')
True
>> x.endswith('boy')
False

3.格式化输出：format
'''
之前我们使用%s来做字符串的格式化输出操作，在传值时，必须严格按照位置与%s一一对应，而字符串的内置方法format则提供了一种不依赖位置的传值方式
'''
# format括号内在传参数时完全可以打乱顺序，但仍然能指名道姓地为指定的参数传值，name=‘tony’就是传给{name}
>>> str4 = 'my name is {name}, my age is {age}!'.format(age=18,name='tony')
>>> str4  
'my name is tony, my age is 18!'

>>> str4 = 'my name is {name}{name}{name}, my age is {name}!'.format(name='tony', age=18)
>>> str4  
'my name is tonytonytony, my age is tony!'

# 类似于%s的用法，传入的值会按照位置与{}一一对应
>>> str4 = 'my name is {}, my age is {}!'.format('tony', 18)
>>> str4 
my name is tony, my age is 18!

# 把format传入的多个值当作一个列表，然后用{索引}取值
>>> str4 = 'my name is {0}, my age is {1}!'.format('tony', 18)
>>> str4
my name is tony, my age is 18!

>>> str4 = 'my name is {1}, my age is {0}!'.format('tony', 18)
>>> str4  
my name is 18, my age is tony!

>>> str4 = 'my name is {1}, my age is {1}!'.format('tony', 18)
>>> str4  
my name is 18, my age is 18!

4.切分：split（从左往右），rsplit（从右往左）---> 切分的值是一个列表
# split会按照从左到右的顺序对字符串进行切分，可以指定切割次数
>>> str5='C:/a/b/c/d.txt'
>>> str5.split('/',1)
['C:', 'a/b/c/d.txt']  

# rsplit刚好与split相反，从右往左切割，可以指定切割次数
>>> str5='a|b|c'
>>> str5.rsplit('|',1)
['a|b', 'c']

5.拼接：jion
# 从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串
>>> '%'.join('hello') 				# 从字符串'hello'中取出多个字符串，然后按照%作为分隔符号进行拼接
'h%e%l%l%o'
>>> '|'.join(['tony','18','read'])  # 从列表中取出多个字符串，然后按照|为分隔符号进行拼接
'tony|18|read'

6.替换：replace
# 用新的字符替换字符串中旧的字符
>>> str7 = 'my name is tony, my age is 18!'  # 将tony的年龄由18岁改成73岁
>>> str7 = str7.replace('18', '73') 		 # 语法:replace('旧内容', '新内容')
>>> str7
my name is tony, my age is 73!

# 可以指定修改的个数
>>> str7 = 'my name is tony, my age is 18!'
>>> str7 = str7.replace('my', 'MY',1) 		 # 只把一个my改为MY
>>> str7
'MY name is tony, my age is 18!'

7.判断数字是否是纯数字：isdigit 
# 判断字符串是否是纯数字组成，返回结果为True或False
>>> str8 = '5201314'
>>> str8.isdigit()
True

>>> str8 = '123g123'
>>> str8.isdigit()
False

字符串的内置方法(了解)

1.find、index：查找字符串的索引
 > a = 'asdwc gggg axsc'
 >> print(a.find('c')) --->查找字符串的索引，找到一个
 >>> 4
 >> print(a.find('c',0,7)) --->指定索引范围来寻找 
 >>> 4  
 >> print(a.index('n'))
 >>> -1

 > a = 'asdwc gggg axsc'
 >> print(a.index('c')) --->查找字符串的索引，找到一个
 >>> 4
 >> print(a.index('c',0,7)) --->指定索引范围来寻找 
 >>> 4  
 >> print(a.index('n'))
 >>> ValueError: substring not found
    
 '''
  find与index同为查找字符串索引，但是当查找的字符串不存在时，find的返回值为-1，index直接报错
 '''   

2.统计字符串在一个整体中出现的次数：count
 > msg = "hello everyone"
 >> msg.count('e')  ---> 统计字符串e出现的次数
 >>> 4
 >> msg.count('e',1,6)  ---> 字符串e在索引1~5范围内出现的次数
 >>> 1

3.字符填充：center,ljust,rjust,zfill
 > name='tony'
 >> name.center(30,'-')  # 总宽度为30，字符串居中显示，不够用-填充，（左右两边填充）
  -------------tony-------------
 >> name.ljust(30,'*')  # 总宽度为30，字符串左对齐显示，不够用*填充，（右边填充）
  tony**************************
 >> name.rjust(30,'*')  # 总宽度为30，字符串右对齐显示，不够用*填充，（左边填充）
  **************************tony
 >> name.zfill(50)  # 总宽度为50，字符串右对齐显示，不够用0填充
  0000000000000000000000000000000000000000000000tony
    
 4.字母大小写：captalize,swapcase,title
 # captalize：首字母大写
 > message = 'i love you!'
 >> message.capitalize()
 >>> I love you!  
 # swapcase：大小写翻转
 > message1 = 'i LoVe yUO! '
 >> message1.swapcase()  
 >>> I lOvE Yuo!  
 # title：每个单词的首字母大写
 > msg = 'i love you!'
 >> msg.title()
 >>> I Love You! 

### 扩展
# 5.is数字系列
#在python3中
num1 = b'4' #bytes
num2 = u'4' #unicode,python3中无需加u就是unicode
num3 = '四' #中文数字
num4 = 'Ⅳ' #罗马数字


#isdigt:bytes,unicode
>>> num1.isdigit()
True
>>> num2.isdigit()
True
>>> num3.isdigit()
False
>>> num4.isdigit() 
False

#isdecimal:uncicode(bytes类型无isdecimal方法)
>>> num2.isdecimal() 
True
>>> num3.isdecimal() 
False
>>> num4.isdecimal() 
False

#isnumberic:unicode,中文数字,罗马数字(bytes类型无isnumberic方法)
>>> num2.isnumeric() 
True
>>> num3.isnumeric() 
True
>>> num4.isnumeric() 
True

# 三者不能判断浮点数
>>> num5 = '4.3'
>>> num5.isdigit()
False
>>> num5.isdecimal()
False
>>> num5.isnumeric()
False

'''
总结:
	最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
	如果要判断中文数字或罗马数字,则需要用到isnumeric。
'''


# 6.is其他
>>> name = 'tony123'
>>> name.isalnum() #字符串中既可以包含数字也可以包含字母
True
>>> name.isalpha() #字符串中只包含字母
False
>>> name.isidentifier()
True
>>> name.islower()  # 字符串是否是纯小写
True
>>> name.isupper()  # 字符串是否是纯大写
False
>>> name.isspace()  # 字符串是否全是空格
False
>>> name.istitle()  # 字符串中的单词首字母是否都是大写
False

列表的内置方法（优先掌握）

1. 类型转换
# print(list(123))  不可
# print(list(1.11)) 不可
print(list('hello')) # ['h', 'e', 'l', 'l', 'o']
print(list([11, 22, 33, 44])) # [11, 22, 33, 44]
print((list({'username':"kevin", "age":20})))  # ['username', 'age']
print(list((11, 22, 33, 44)))  # [11, 22, 33, 44]
print(list({11, 22, 33, 44}))  # [33, 11, 44, 22]

2.取值：按索引取值
 # 正向取(从左往右)
 > my_friends=['tony','jason','tom',4,5]
 >> my_friends[0]  
 >>> tony
 # 反向取(负号表示从右往左)
 >> my_friends[-1]  
 >>> 5

2.切分：按索引切（顾头不顾尾）
 # 取出索引为0到3的元素
 > friend = ['gg', 'xx', 'yy', 'nn', 'ww', 'ss']
 >> friend[0:3] 
 >>> ['gg', 'xx', 'yy']
 # 步长：0:6:3,第三个参数3代表步长，会从0开始，每次累加一个3即可，所以会取出索引0、3的元素
 >> friend[0:6:3] 
 >>> ['gg', 'nn']

3.长度：len ---> 列表的最大索引时len的长度减一
 > friend = ['gg', 'xx', 'yy', 'nn', 'ww', 'ss']
 >> print(len(friend))   
 >>> 6
    
4. 列表的增删改
# 修改值
 > friend = ['gg', 'xx', 'yy']
 >> print(friend[0])
 >>> gg
 > friend[0] = 'nn'
 >> print(friend)
 >>> ['nn', 'xx', 'yy']

# 添加值：qppend、extend、insert
## append 在列表尾部追加一个元素
 > a = [11, 22, 33]
 >> a.append(44)
 >>> [11, 22, 33, 44] 

## extend 在列表尾部一次性添加多个元素
 > a = [11, 22]
 > b = [33, 44]  
 >> a.extend(b)
 >>> [11, 22, 33, 44]

## insert 按索引位置插入元素
 > a = [1, 2, 3] 
 >> print(a[0])
 >>> 1
 >> a.insert(0,4)
 >>> [4, 1, 2, 3]
    
 # 删除值：del、pop、remove
 ## del 按照索引删除
 > a = [1, 2, 3] 
 >> del a[0]
 >>> [2, 3]

 ## pop 弹出值，有返回值
 > a = [1, 2, 3] 
 >> a.pop()      
 >>> [1, 2]
              '''pop可以按照索引删除，如果不加索引就会删除列表最后一个元素 '''
 >> a.pop(1)
 >>> [1, 3]   
    
 ## remove 按照具体的元素删除，没有返回值
 > a = [1, 2, 3, 4] 
 >> a.remove(4)      
 >>> [1, 2, 3]
     
5.颠倒列表里的元素：reverse
 > a = [1, 2, 3, 4]
 >> a.reverse()
 >>> [4, 3, 2, 1]
    
6.排序：sort
# 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
 > l = [11,22,3,42,7,55]
 >> l.sort()
 >>> l 
 [3, 7, 11, 22, 42, 55]  # 默认从小到大排序
 >> l = [11,22,3,42,7,55]
 >> l.sort(reverse=True)  # reverse用来指定是否跌倒排序，默认为False
 >>> l 
 [55, 42, 22, 11, 7, 3]

元组的内置方法

>>> tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33) 
# 1、按索引取值(正向取+反向取)：只能取，不能改否则报错！  
>>> tuple1[0]
1
>>> tuple1[-2]
22
>>> tuple1[0] = 'hehe'  # 报错：TypeError:
 
# 2、切片(顾头不顾尾，步长)
>>> tuple1[0:6:2] 
(1, 15000.0, 22)
 
# 3、长度
>>> len(tuple1)  
6
 
# 4、成员运算 in 和 not in
>>> 'hhaha' in tuple1 
True
>>> 'hhaha' not in tuple1  
False 
 
# 5、循环
>>> for line in tuple1:
...     print(line)
1
hhaha
15000.0
11
22
33

############
# 当元组的里的元素只有一个的时候一定要加逗号，不然元组的类型就是括号里面的数据类型
t = (111)
t1 = (111.11)
t2 = ('hello')
t3 = ('hello', )

print(type(t)) # <class 'int'>
print(type(t1)) # <class 'float'>
print(type(t2)) # <class 'str'>
print(type(t3)) # <class 'tuple'>

字典的内置方法

# 定义：在{}内用逗号分隔开多元素，每一个元素都是key:value的形式，其中value可以是任意类型，而key则必须是不可变类型，详见第八小节，通常key应该是str类型，因为str类型会对value有描述性的功能
info={'name':'tony','age':18,'sex':'male'} #本质info=dict({....})
# 也可以这么定义字典
info=dict(name='tony',age=18,sex='male') # info={'age': 18, 'sex': 'male', 'name': 'tony'}


# 转换1: 
>>> info=dict([['name','tony'],('age',18)])
>>> info
{'age': 18, 'name': 'tony'}
 
# 转换2：fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中
>>> {}.fromkeys(('name','age','sex'),None)  
{'age': None, 'sex': None, 'name': None}

# 1、按key存取值：可存可取
# 1.1 取
>>> dic = {
...     'name': 'xxx',
...     'age': 18,
...     'hobbies': ['play game', 'basketball']
... }
>>> dic['name']
'xxx'
>>> dic['hobbies'][1]
'basketball'
# 1.2 对于赋值操作，如果key原先不存在于字典，则会新增key:value
>>> dic['gender'] = 'male'  
>>> dic
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball'],'gender':'male'}
# 1.3 对于赋值操作，如果key原先存在于字典，则会修改对应value的值
>>> dic['name'] = 'tony'
>>> dic
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball']}
 
# 2、长度len
>>> len(dic) 
3
 
# 3、成员运算in和not in
>>> 'name' in dic  # 判断某个值是否是字典的key
True
 
# 4、删除
>>> dic.pop('name')  # 通过指定字典的key来删除字典的键值对
>>> dic
{'age': 18, 'hobbies': ['play game', 'basketball']}
 
# 5、键keys()，值values()，键值对items()
>>> dic = {'age': 18, 'hobbies': ['play game', 'basketball'], 'name': 'xxx'}
# 获取字典所有的key
>>> dic.keys()  
dict_keys(['name', 'age', 'hobbies'])
# 获取字典所有的value
>>> dic.values()
dict_values(['xxx', 18, ['play game', 'basketball']])
# 获取字典所有的键值对
>>> dic.items()
dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])
 
# 6、循环
# 6.1 默认遍历的是字典的key
>>> for key in dic:
...     print(key)
... 
age
hobbies
name
# 6.2 只遍历key
>>> for key in dic.keys():
...     print(key)
... 
age
hobbies
name
# 6.3 只遍历value
>>> for key in dic.values():
...     print(key)
... 
18
['play game', 'basketball']
xxx
# 6.4 遍历key与value
>>> for key in dic.items():
...     print(key)
... 
('age', 18)
('hobbies', ['play game', 'basketball'])
('name', 'xxx')

# get()
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.get('k1')
'jason'  # key存在，则获取key对应的value值
>>> res=dic.get('xxx') # key不存在，不会报错而是默认返回None
>>> print(res)
None  
>>> res=dic.get('xxx',666) # key不存在时，可以设置默认返回的值
>>> print(res)
666 
# ps:字典取值建议使用get方法

# pop()
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> v = dic.pop('k2')  # 删除指定的key对应的键值对,并返回值
>>> dic
{'k1': 'jason', 'kk2': 'JY'}
>>> v
'Tony'


# del
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> del dic['k3']  # 删除指定的key对应的键值对
>>> dic
{'k1': 'jason', 'kk2': 'JY'}


# popitem
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> item = dic.popitem()  # 随机删除一组键值对,并将删除的键值放到元组内返回
>>> dic
{'k3': 'JY', 'k2': 'Tony'}
>>> item
('k1', 'jason')


# update 用新字典更新旧字典，有则修改，无则添加
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.update({'k1':'JN','k4':'xxx'})
>>> dic
{'k1': 'JN', 'k3': 'JY', 'k2': 'Tony', 'k4': 'xxx'}

# fromkeys() 
>>> dic = dict.fromkeys(['k1','k2','k3'],[])
>>> dic
{'k1': [], 'k2': [], 'k3': []}


# setdefault()
# key不存在则新增键值对，并将新增的value返回
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k3',333)
>>> res
333
>>> dic # 字典中新增了键值对
{'k1': 111, 'k3': 333, 'k2': 222}
 
# key存在则不做任何修改，并返回已存在key对应的value值
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k1',666)
>>> res
111
>>> dic # 字典不变
{'k1': 111, 'k2': 222}

集合

"""
定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：
     1：每个元素必须是不可变类型
     2：集合内没有重复的元素
     3：集合内元素无序
"""
s = {1,2,3,4}  # 本质 s = set({1,2,3,4})
 
# 注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。
 
# 注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，现在我们想定义一个空字典和空集合，该如何准确去定义两者?
d = {} # 默认是空字典 
s = set() # 这才是定义空集合


# 类型转换
# 但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型
>>> s = set([1,2,3,4])
>>> s1 = set((1,2,3,4))
>>> s2 = set({'name':'jason',})
>>> s3 = set('egon')
>>> s,s1,s2,s3
{1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'e', 'o', 'g', 'n'}


# 使用
>>> friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们 
>>> friends2 = {"Jy","ricky","jason","egon"}   # 用户2的好友们

 
# 1.合集/并集(|)：求两个用户所有的好友（重复好友只留一个）
>>> friends1 | friends2
{'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}
 
# 2.交集(&)：求两个用户的共同好友
>>> friends1 & friends2
{'jason', 'egon'}
 
# 3.差集(-)：
>>> friends1 - friends2 # 求用户1独有的好友
{'kevin', 'zero'}
>>> friends2 - friends1 # 求用户2独有的好友
{'ricky', 'Jy'}
 
# 4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）
>>> friends1 ^ friends2
{'kevin', 'zero', 'ricky', 'Jy'}
 
# 5.值是否相等(==)
>>> friends1 == friends2
False
 
# 6.父集：一个集合是否包含另外一个集合
# 6.1 包含则返回True
>>> {1,2,3} > {1,2}
True
>>> {1,2,3} >= {1,2}
True
# 6.2 不存在包含关系，则返回False
>>> {1,2,3} > {1,3,4,5}
False
>>> {1,2,3} >= {1,3,4,5}
False
 
# 7.子集
>>> {1,2} < {1,2,3}
True
>>> {1,2} <= {1,2,3}
True	

# 去重
'''
# 1. 只能针对不可变类型
# 2. 集合本身是无序的，去重之后无法保留原来的顺序
'''

>>> l=['a','b',1,'a','a']
>>> s=set(l)
>>> s # 将列表转成了集合
{'b', 'a', 1}
>>> l_new=list(s) # 再将集合转回列表
>>> l_new
['b', 'a', 1] # 去除了重复，但是打乱了顺序
 
# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
l=[
    {'name':'lili','age':18,'sex':'male'},
    {'name':'jack','age':73,'sex':'male'},
    {'name':'tom','age':20,'sex':'female'},
    {'name':'lili','age':18,'sex':'male'},
    {'name':'lili','age':18,'sex':'male'},
]
 
new_l=[]
 
for dic in l:
    if dic not in new_l:
        new_l.append(dic)
 
print(new_l)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
[
    {'age': 18, 'sex': 'male', 'name': 'lili'}, 
    {'age': 73, 'sex': 'male', 'name': 'jack'}, 
    {'age': 20, 'sex': 'female', 'name': 'tom'}
]

可变类型与不可变类型

"""
	可变类型：列表
		值改变，内存地址没有改变
	不可变类型：整型 浮点型 字符串
		值改变，内存地址也改变
"""