Python开发2——基本数据类型
基本数据类型
一、字符串 str：不可变数据类型
1、字符串首字母大写：
# def capitalize(self): # eg： string = 'helLo' new_string = string.capitalize() print(new_string)
注：①自身不变，会生成一个新的值
②当字符串中非首字母为大写时，capitalize会将其变为小写
2、将所有大写变小写（casefold更牛逼，可以变化德语等）：
#def casefold(self): string = 'hElLo' new_string = string.casefold() print(new_string)
3、将所有大写变小写：
#def lower(self): string = 'hElLo' new_string = string.lower() print(new_string)
4、将所有小写变大写：
#def upper(self): string = 'hElLo' new_string = string.upper() print(new_string)
5、大小写转换：
#def swapcase(self): name = "AnGKji" v = name.swapcase() print(v)
6、所有的字母是否都为小写：
#def islower(self): string = 'haAa' print(string.islower())
7、所有的字母是否都为大写：
#def isupper(self): string = 'FFAF' print(string.isupper())
8、文本居中：
#def center(self, width, fillchar=None): # width: 表示总长度 # fillchar：空白处填充的字符（长度为1，默认为空格） string = 'hElLo' new_string = string.center(20,'*') print(new_string)
9、填充：
①文本居左：
#def ljust(self, width, fillchar=None): name = 'aaaa' v = name.ljust(20,'*') print(v)
②文本居右：
#def rjust(self, width, fillchar=None): name = 'aaaa' v = name.rjust(20,'*') print(v)
③文本居右（前面用0填充）：
def zfill(self, width):
10、子串在字符串中出现的次数：
#def count(self, sub, start=None, end=None):
# sub：要查找的值（子序列）
# start：起始位置（索引，默认为0）
# end：结束位置（索引，默认为末尾）
string = 'hElLohellohello'
val= string.count('he')
print(val)
11、将字符串转换成其他编码的字符串：
#def encode(self, encoding='utf-8', errors='strict'):
#默认转换为utf-8
name = '哈哈哈'
print(name.encode('gbk'))
12、是否以某字符串结尾：
#def endswith(self, suffix, start=None, end=None):
string = 'hElLohellohello'
print(string.endswith('llo'))
13、是否以某字符串开头：
#def startswith(self, prefix, start=None, end=None):
string = 'hElLohellohello'
print(string.startswith('llo'))
14、找到制表符\t,进行替换（包含前面的值）：
#def expandtabs(self, tabsize=8):
# tabsize -- 指定转换字符串中的 tab 符号('\t')转为空格的字符数 name = "al\te\tx\nalex\tuu\tkkk" v = name.expandtabs(20) print(v)
15、查找：
①找到指定子序列第一次出现的索引位置：不存在返回-1：
def find(self, sub, start=None, end=None):
#def find(self, sub, start=None, end=None):
string = 'hElLohellohello' print(string.find('he'))
②找到指定子序列最后一次出现的位置：不存在返回-1：
def rfind(self, sub, start=None, end=None):
16、查找：
①返回指定子序列开始的索引位置：不存在报错：
def index(self, sub, start=None, end=None):
#def index(self, sub, start=None, end=None):
name = 'hahahhaha'
print(name.index('hh'))
②返回指定子序列最后一次出现位置：不存在报错：
def rindex(self, sub, start=None, end=None):
17、字符串格式化
①占位符：
message = '我叫小李，性别：%s,我今年%s岁!'
new_message = message %('女',19,)
print(new_message)
message1 = '我叫小李，性别：%s,我今年%s岁!' %('女',19,)
print(message1)
②def format(self, *args, **kwargs):
#def format(self, *args, **kwargs):
message = "我是:{0};年龄:{1};性别:{2}"
v = message.format("小李",19,'女')
print(v)
message1 = "我是:{name};年龄:{age};性别:{gender}"
v1 = message1.format(name='小李',age=19,gender='女')
print(v1)
③def format_map(self, mapping):（参数为字典）
#def format_map(self, mapping):
message = "我是:{name};年龄:{age};性别:{gender}"
v = message.format_map({'name':"小李",'age':19,'gender':'女'})
print(v)
18、判断是否是数字、汉字：
①def isalnum(self): #检测字符串是否由字母和数字组成
②def isalpha(self): #检测字符串是否只由字母组成
③def isdecimal(self): #检查字符串是否只包含十进制字符。这种方法只存在于unicode对象
# '123'
#注：定义一个字符串为Unicode，只需要在字符串前添加 'u' 前缀即可
④def isdigit(self): #检测字符串是否只由数字组成
# '123'，'②'
⑤def isnumeric(self): #检测字符串是否只由数字组成,这种方法是只针对unicode对象
# '123'，'二'，'②'
19、是否是合法标识符（未识别关键字）：
#def isidentifier(self): string = 'haha' print(string.isidentifier()
20、内容是否都是可打印的：
#def isprintable(self): string = 'haAa\nshgkjr' print(string.isprintable())
21、是否全部是空格：
#def isspace(self): string = ' 21 ' print(string.isspace())
22、字符串中所有的单词拼写首字母是否为大写，且其他字母为小写：
#def istitle(self): string = 'hello Hi' print(string.istitle())
23、元素拼接：
#def join(self, iterable): string = 'nishi' v = "_".join(string) # 内部循环每个元素 print(v) name_list = ['你是','谁','啥','呀'] v1 = "哈哈h".join(name_list) print(v1)
24、移除（默认为空白：空格、\n、\t）
①移除字符串头尾指定的字符：
#def strip(self, chars=None):
name = 'aaaa\t'
v = name.strip() # 默认移除：空格,\n,\t
print(v)
string = 'aaa***'
print(string.strip('*'))
②移除字符串左边指定的字符：
def lstrip(self, chars=None):
③移除字符串右边指定的字符：
def rstrip(self, chars=None):
25、对应关系 + 翻译：
#def maketrans(self, intab, outtab): #创建字符映射的转换表
#intab：字符串，表示需要转换的字符
#outtab：字符串，表示转换的目标
#def translate(self, table):
m = str.maketrans('aeiou','12345') # 对应关系 name = "akpsojfasdufasdlk fj8ausdfakjsdfl;kjer09asdf" v = name.translate(m) print(v)
26、分割，保留分割的元素：
①左边分割：
def partition(self, sep):
#def partition(self, sep):
content = "刘涛#蒋欣#杨紫"
v = content.partition('#')
print(v) #结果为('刘涛', '#', '蒋欣#杨紫')
②右边分割：
def rpartition(self, sep):
#def partition(self, sep):
content = "刘涛#蒋欣#杨紫"
v = content.rpartition('#')
print(v) #结果为('刘涛#蒋欣', '#', '杨紫')
27、切片（返回分割后的字符串列表：可以指定分割次数）：
①从左切片：
def split(self, sep=None, maxsplit=-1):
#def split(self, sep=None, maxsplit=-1):
#sep：分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等
#maxsplit：分割次数
string = "this is string example....wow!!!"
print (string.split( ))
print (string.split('i',1))
print (string.split('w'))
②从右切片：
def rsplit(self, sep=None, maxsplit=-1):
③按照行('\r', '\r\n', \n')分隔：
def splitlines(self, keepends=None):
#def splitlines(self, keepends=None): #返回一个包含各行作为元素的列表 #如果参数 keepends 为 False，不包含换行符；如果为 True，则保留换行符 string = 'ab c\n\nde fg\rkl\r\n' print(string.splitlines()) print(string.splitlines(1))
28、替换：
#def replace(self, old, new, count=None):
content = "刘涛#蒋欣#杨紫"
v = content.replace('#','haha')
print(v)
v1 = content.replace('#','haha',1)
print(v1)
29、"标题化"字符串：即所有单词都是以大写开始，其余字母均为小写：
#def title(self): string = "this is string example from runoob....wow!!!" print (string.title())
二、列表 list：可变数据类型
1、列表中增加元素
①追加(在列表末尾添加新的对象):
#def append(self, p_object):
li = ['Google', 'Runoob', 'Taobao']
li.append('Baidu')
print ("更新后的列表 : ", li)
②扩展列表：
#def extend(self, iterable): user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] user_list.extend(['郭少龙','郭少霞']) print(user_list)
2、插入：将指定对象插入列表的指定位置：
#def insert(self, index, p_object):
li = ['Google', 'Runoob', 'Taobao']
li.insert(1, 'Baidu')
print ('列表插入元素后为 : ', li)
3、删除
①清空列表:
#def clear(self):
li = ['Google', 'Runoob', 'Taobao', 'Baidu']
li.clear()
print ("列表清空后 : ", li)
②删除列表中元素：
a、根据索引移除某一元素——用索引删除：
del li[i]
b、移除列表中某个值的第一个匹配项——用值删除：
def remove(self, value)：
#def remove(self, value):
li = ['Google', 'Runoob', 'Taobao', 'Baidu','Taobao']
li.remove('Taobao')
print ("列表现在为 : ", li)
③删除并且获取元素（默认最后一个）——用索引删除：
#def pop(self, index=None):
li = ['Google', 'Runoob', 'Taobao']
v = li.pop()
print ("列表现在为 : ", li)
print('删除的元素为：',v)
v1 = .pop(1)
print ("列表现在为 : ", li)
print('删除的元素为：',v1)
4、拷贝(浅拷贝)：
#def copy(self):
li = ['Google', 'Runoob', 'Taobao', 'Baidu']
li1 = li.copy()
print ("li1 列表: ", li1)
5、统计某个元素在列表中出现的次数：
#def count(self, value):
aList = [123, 'Google', 'Runoob', 'Taobao', 123];
print ("123 元素个数 : ", aList.count(123))
6、找出某个值第一个匹配项的索引位置：没有,则报错：
#def index(self, value, start=None, stop=None):
li = ['Google', 'Runoob', 'Taobao']
print ('Runoob 索引值为', li.index('Runoob'))
7、翻转（反向列表中元素）:
#def reverse(self):
li = ['Google', 'Runoob', 'Taobao', 'Baidu']
li.reverse()
print ("列表反转后: ", li)
8、排序：
#def sort(self, key=None, reverse=False): nums = [11,22,3,3,9,88] print(nums) #排序，从小到大 nums.sort() print(nums) #从大到小 nums.sort(reverse=True) print(nums)
强插：range,enumrate
1、range：
- py2.7：
range(start, stop[, step]) #立即生成所有数字
xrange(start, stop[, step]) #不会立即生成，迭代之后才一个一个创建；
- py3.x
range(start, stop[, step]) #不会立即生成，迭代之后才一个一个创建；
start: 起始位置，默认从 0 开始
end: 结束位置，但不包括 end
step：步长，默认为1
for i in range(1,11):
print(i)
for i in range(1,11,2):
print(i)
for i in range(10,0,-1):
print(i)
li = ['eric','alex','tony']
# range,len,li循环
for i in range(0,len(li)):
ele = li[i]
print(ele)
li = ['eric','alex','tony']
for i in li:
print(i)
for i in range(0,len(li)):
print(i+1,li[i])
2、enumerate额外生成一列有序的数字：
enumerate(sequence, [start=0])
#将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列
li = ['eric','alex','tony']
for i,ele in enumerate(li,1):
print(i,ele)
v = input('请输入商品序号：')
v = int(v)
item = li[v-1]
print(item)
三、元组 tuple：不可变类型（不可被修改的列表）
注：****** 元组最后，加逗号 ******
1、获取个数：
#def count(self, value):
user_tuple = ('alex','eric','seven','alex')
v = user_tuple.count('alex')
print(v)
2、获取值的第一个索引位置：
#def index(self, value, start=None, stop=None):
user_tuple = ('alex','eric','seven','alex')
v = user_tuple.index('alex')
print(v)
四、字典 dict：可变数据类型
1、清空：
#def clear(self):
d = {'Name': 'Zara', 'Age': 7}
d.clear()
print(d)
2、浅拷贝：
#def copy(self):
d1 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
d2 = d1.copy()
print ("新复制的字典为 : ",d2)
3、创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值：
def fromkeys(*args, **kwargs):
#def fromkeys(*args, **kwargs): dic = dict.fromkeys(['k1','k2','k3'],123) print(dic) dic = dict.fromkeys(['k1','k2','k3'],123) dic['k1'] = 'asdfjasldkf' print(dic) dic1 = dict.fromkeys(['k1','k2','k3'],[1,]) dic1['k1'].append(222) print(dic1)
4、根据key获取指定的value；不存在返回默认值：
def get(self, key, default=None):
#def get(self, key, default=None):
dic = {'Name': 'Runoob', 'Age': 27}
print ("Age 值为 : %s" % dict.get('Age'))
print ("Sex 值为 : %s" % dict.get('Sex', "NA"))
5、删除并获取对应的value值：
#def pop(self, k, d=None):
dic = {'k1':'v1','k2':'v2'}
v = dic.pop('k1')
print(dic)
print(v)
6、随机删除键值对，并获取到删除的键值：
#def popitem(self):
dic = {'k1':'v1','k2':'v2'}
v = dic.popitem()
print(dic)
print(v)
k,v = dic.popitem() # ('k2', 'v2')
print(dic)
print(k,v)
v = dic.popitem() # ('k2', 'v2')
print(dic)
print(v[0],v[1])
7、增加，如果存在则不做操作：
#def setdefault(self, k, d=None):
dic = {'k1':'v1','k2':'v2'}
dic.setdefault('k3','v3')
print(dic)
dic.setdefault('k1','1111111')
print(dic)
8、批量增加或修改：
#def update(self, E=None, **F):
dic = {'k1':'v1','k2':'v2'}
dic.update({'k3':'v3','k1':'v24'})
print(dic)
五、集合 set：可变类型（不可重复的列表）
1、集合中添加元素
①添加一项：
#def add(self, *args, **kwargs):
s = {"alex",'eric','tony'}
s.add('aaa')
print(s1)
②在集合s中添加多项：
#def update(self, *args, **kwargs):
s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony','刘一'}
s1.update(s2)
print(s1)
3、删除
①删除集合中的所有元素：
#def clear(self, *args, **kwargs):
s = {"alex",'eric','tony'}
s.clear()
print(s)
②移除集合中指定元素：
#def discard(self, *args, **kwargs):
s = {"alex",'eric','tony'}
s.discard('eric')
print(s)
③随机删除并返回集合s中的一个元素, 如果s为空则报错：
#def pop(self, *args, **kwargs):
s = {"alex",'eric','tony'}
v = s.pop()
print(s)
print(v)
④删除集合s中的元素，不存在则报错：
#def remove(self, *args, **kwargs):
s = {"alex",'eric','tony'}
s.remove('eric')
print(s)
4、浅复制：
#def copy(self, *args, **kwargs):
s = {"alex",'eric','tony'}
print(s.copy())
5、获得s1中有s2中没有的元素的集合（s1与s2没改变）：s1.difference(s2)
#def difference(self, *args, **kwargs):
s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony','刘一'}
print(s1.difference(s2))
6、将s1中有s2中没有的元素重新赋值给s1（s2未改变）：s1.difference_update(s2)
#def difference_update(self, *args, **kwargs):
s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony','刘一'}
s1.difference_update(s2)
print(s1)
print(s2)
7、获取并集：
#def union(self, *args, **kwargs):
s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony','刘一'}
v = s1.union(s2)
print(v)
8、获取交集：
#def intersection(self, *args, **kwargs):
s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony','刘一'}
print(s1.intersection(s2))
9、将s1与s2的交集重新赋值给s1（s2未改变）：s1.intersection_update(s2)
#def intersection_update(self, *args, **kwargs):
s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony','刘一'}
s1.intersection_update(s2)
print(s1)
10、获取s1与s2中不重复的元素的集合：
#def symmetric_difference(self, *args, **kwargs):
s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony','刘一'}
print(s1.symmetric_difference(s2))
11、将s1与s2中不重复的元素的集合重新赋值给s1（s2未改变）：s1.symmetric_difference_update(s2)
#def symmetric_difference_update(self, *args, **kwargs):
s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony','刘一'}
s1.symmetric_difference_update(s2)
print(s1)
12、检测s1是否为s2的子集：
#def issubset(self, *args, **kwargs):
s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony','刘一'}
print(s1.issubset(s2))
13、检测s1是否为s2的父集：
#def issuperset(self, *args, **kwargs):
s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony','刘一'}
print(s1.issuperset(s2))
14、检测s1与s2是否不为交集：
#def isdisjoint(self, *args, **kwargs):
s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony','刘一'}
print(s1.isdisjoint(s2))
##### 额外：
s1 = {"alex",'eric','tony','李泉','李泉11'}
for i in s1:
print(i)
s1 = {"alex",'eric','tony','李泉','李泉11',(11,22,33)}
for i in s1:
print(i)
浙公网安备 33010602011771号