

首页  思维导图  详情



基本数据类型

2020-08-21 14:56:00   0  举报





仅支持查看

AI智能生成

Python 基本数据类型及操作方法

Python 基本数据类型

模版推荐

作者其他创作

大纲/内容

数字（Number）

加  + 减  - 乘  * 除  / 取整 // 幂 ** 取余 %

包含：     整数（int）     浮点数（fioat）     复数（complex）

数学函数

abs(x)：返回数字的绝对值，如abs(-10) 返回 10

ceil(x)：返回数字的上入整数，如math.ceil(4.1) 返回 5

exp(x)：返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045

fabs(x)：返回数字的绝对值，如math.fabs(-10) 返回10.0

floor(x)：返回数字的下舍整数，如math.floor(4.9)返回 4

log(x)：如math.log(math.e)返回1.0,math.log(100,10)返回2.0

log10(x)：返回以10为基数的x的对数，如math.log10(100)返回 2.0

max(x1, x2,...)：返回给定参数的最大值，参数可以为序列。

min(x1, x2,...)：返回给定参数的最小值，参数可以为序列。

modf(x)：返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。

pow(x, y)：x**y 运算后的值。

round(x [,n])：返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。                         其实准确的说是保留值将保留到离上一位更近的一端。

sqrt(x)：返回数字x的平方根。

元祖（tuple）

创建空元组： tup1 = ()

修改元祖：元祖一旦初识创建，无法修改

tup1 = (12, 34.56) tup2 = ('abc', 'xyz') # 以下修改元组元素操作是非法的。 # tup1[0] = 100 # 创建一个新的元组 tup3 = tup1 + tup2 print (tup3) (12, 34.56, 'abc', 'xyz')

集合（set）

集合（set）是一个无序的不重复元素序列。 可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

内置方法

add()：为集合添加元素

fruits = {"apple", "banana", "cherry"} fruits.add("orange") print(fruits) {'apple', 'banana', 'orange', 'cherry'}

clear()：移除集合中的所有元素

fruits = {"apple", "banana", "cherry"} fruits.clear() print(fruits) set()

copy()：拷贝一个集合

fruits = {"apple", "banana", "cherry"} x = fruits.copy() print(x) {'cherry', 'banana', 'apple'}

difference()：返回多个集合的差集

x = {"apple", "banana", "cherry"} y = {"google", "microsoft", "apple"} z = x.difference(y) print(z) {'cherry', 'banana'}

difference_update()：移除集合中的元素，该元素在指定的集合也存在。

x = {"apple", "banana", "cherry"} y = {"google", "microsoft", "apple"} x.difference_update(y) print(x) {'cherry', 'banana'}

discard()：删除集合中指定的元素

fruits = {"apple", "banana", "cherry"} fruits.discard("banana") print(fruits) {'cherry', 'apple'}

intersection()：返回集合的交集

x = {"apple", "banana", "cherry"} y = {"google", "runoob", "apple"} z = x.intersection(y) print(z) {'apple'}

intersection_update()：返回集合的交集。

x = {"apple", "banana", "cherry"} y = {"google", "runoob", "apple"} x.intersection_update(y) print(x) {'apple'}

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

x = {"apple", "banana", "cherry"} y = {"google", "runoob", "facebook"} z = x.isdisjoint(y) print(z) True

issubset()：判断指定集合是否为该方法参数集合的子集。

x = {"a", "b", "c"} y = {"f", "e", "d", "c", "b", "a"} z = x.issubset(y) print(z)

issuperset()：判断该方法的参数集合是否为指定集合的子集

x = {"f", "e", "d", "c", "b", "a"} y = {"a", "b", "c"} z = x.issuperset(y) print(z) True

pop()：随机移除元素

fruits = {"apple", "banana", "cherry"} fruits.pop() print(fruits) {'apple', 'banana'}

remove()：移除指定元素

fruits = {"apple", "banana", "cherry"} fruits.remove("banana") print(fruits) {'cherry', 'apple'}

symmetric_difference()：返回两个集合中不重复的元素集合。

x = {"apple", "banana", "cherry"} y = {"google", "runoob", "apple"} z = x.symmetric_difference(y) print(z) {'google', 'cherry', 'banana', 'runoob'}

symmetric_difference_update()：移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

x = {"apple", "banana", "cherry"} y = {"google", "runoob", "apple"} x.symmetric_difference_update(y) print(x) {'google', 'cherry', 'banana', 'runoob'}

union()：返回两个集合的并集

x = {"apple", "banana", "cherry"} y = {"google", "runoob", "apple"} z = x.union(y) print(z) {'cherry', 'runoob', 'google', 'banana', 'apple'}

update()：给集合添加元素

x = {"apple", "banana", "cherry"} y = {"google", "runoob", "apple"} x.update(y) print(x) {'banana', 'apple', 'google', 'runoob', 'cherry'}

集合的运算

交集（&）

s = {1,2,3,4,5} s2 = {3,4,5,6,7} result = s & s2      # {3, 4, 5}

并集（|）

s = {1,2,3,4,5} s2 = {3,4,5,6,7} result = s | s2         # {1,2,3,4,5,6,7}

叉集（-）

s = {1,2,3,4,5} s2 = {3,4,5,6,7} result = s - s2         # {1, 2}

异或集（ˆ）

s = {1,2,3,4,5} s2 = {3,4,5,6,7} result = s ^ s2         # {1, 2, 6, 7}

子集（<=） 真子集(<)

a = {1,2,3} b = {1,2,3,4,5} result = a <= b # True result = {1,2,3} <= {1,2,3} # True result = {1,2,3,4,5} <= {1,2,3} # False result = {1,2,3} < {1,2,3} # False result = {1,2,3} < {1,2,3,4,5} # True

超集(>=) 真超集(>)

子主题

字节（byte）

字符串（str）

索引：起始下标为0 (从前往后数)，末尾下标为-1(从后往前数)

str_a = 'hello python' print(str_a[0])　　#打印结果：h print(str_a[-1])　　#打印结果：n

切片：格式：[起始位置：终止位置：步长]，默认的步长为1

str_a = 'hello python' print(str_a[0:12:3])　　#打印结果：hlph

拼接：字符串有两种拼接方法， 第一种：str1+str2　　 第二种：','.join((str1,str2))，join方法内的参数是一个可迭代类型的数据

str_a = 'hello' str_b = 'python' print(str_a + str_b)　　#打印结果：hellopython print(','.join((str_a, str_b)))　　#打印结果：hello,python

内置方法

capitalize() :首字母大写

>>> a='Hello World' >>> print(a.capitalize()) Hello world

center():将字符串放入中心位置可指定长度以及位置两边字符

str.center() >>> a='hello world' >>> print(a.center(40,'*')) **************hello world***************

count()：统计字符串片段在字符串中出现的次数，统计子串出现的次数，若不存在则返回0

str_a = '123abc456def456abc456' res = str_a.count('456')　　#res的结果为3

casefold()：把字符串全变小写

>> > c = 'Alex Li' >> > c.casefold() 'alex li'

find(参数1，参数2)：查找字符串片段在字符串中出现的起始下标位置， 参数1表示要查找的字串，参数2表示查找的起始位置，如果没有找到字串则返回-1

str_a = '123abc456def' res = str_a.find('c', 3)　　#res的结果为5

rfind(str, beg=0,end=len(string)):类似于 find()函数，不过是从右边开始查找

子主题

format(self, *args, **kwargs):格式化输出

>> > s = "Welcome {0} to Apeland,you are No.{1} user." >> > s.format("Eva", 9999) 'Welcome Eva to Apeland,you are No.9999 user.' >> > s1 = "Welcome {name} to Apeland,you are No.{user_num} user." >> > s1.format(name="Alex", user_num=999) 'Welcome Alex to Apeland,you are No.999 user.'

replace(参数1，参数2，参数3)：替换指定的字符串片段， 参数1表示要替换的字符串片段，参数2表示替换之后的字符串片段，参数3指定替换的次数(默认为替换所有的)

str_a = '123abc456def456456' res = str_a.replace('456', '789', 2)　　#res的结果为123abc789def789456

split(参数1，参数2)：指定分割点对字符串进行分割， 参数1表示分割点，参数2指定分割的次数(默认找到的所有分割点及您进行分割)

str_a = '123abc456def456abc456' res = str_a.split('abc', 1)　　#res的结果为['123', '456def456abc456']

upper()：将小写字母转为大写字母

str_a = '123aBc456DeF456Abc456' res = str_a.upper()　　#res的结果为123ABC456DEF456ABC456

lower()：将大写字母转为小写字母

str_a = '123aBc456DeF456Abc456' res = str_a.lower()　　#res的结果为123abc456def456abc456

len():返回字符串的长度

>>>str = "runoob" >>> len(str) # 字符串长度 6

swapcase() :大小写互换

>>> a='Hello World' >>> print(a.swapcase()) hELLO wORLD

strip()：删除字符串两边的指定字符，括号的写入指定字符，默认为空格

a='   hello   ' b=a.strip() print(b)            #  'hello'

rstrip():删除字符串右边的指定字符，括号的写入指定字符，默认空格

>>> a='   hello   ' >>> b=a.rstrip() >>> print(b)   hello

lstrip():删除字符串左边的指定字符，括号的写入指定字符，默认空格

>>> a='     hello     ' >>> b=a.lstrip() >>> print(b) hello         #右边空格可能看的不是很明显

join():连接2个字符串,可指定连接符号

li=["alex","eric"] s="******".join(li) print(s) 输出结果　　alex******eric

index():检测字符串中是否包含子字符串str，可指定范围，和find()一样，唯一不同点在于当找不到子串时，抛出ValueError错误。

子主题

字符串的测试、判断函数，这一类函数在string模块中没有，这些函数返回的都是bool值

1 S.startswith(prefix[,start[,end]])        # 是否以prefix开头 2 S.endswith(suffix[,start[,end]])          # 以suffix结尾 3 S.isalnum()      # 否全是字母和数字，并至少有一个字符 4 S.isalpha()       # 是否全是字母，并至少有一个字符 5 S.isdigit()         # 是否全是数字，并至少有一个字符 6 S.isspace()       # 是否全是空白字符，并至少有一个字符 7 S.islower()        # S中的字母是否全是小写 8 S.isupper()       # S中的字母是否便是大写 9 S.istitle()           # S是否是首字母大写的 10 S.isprintable()  # 是否是可打印字符(例如制表符、换行符就不是可打印字符，但空格是) 11 S.isdecimal()    # 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

partition():分割，前中后三部分

s="alex SB alex" ret = s.partition('SB') print(ret) # 输出元组 ('alex ', 'SB', ' alex')

splitlines():根据换行执行分割

s="alex\nalec" ret=s.splitlines() print(ret) # 输出结果 ['alex', 'alec']

swapcase():大写变小写，小写变大写

s="alExAlec" ret=s.swapcase() print(ret) # 输出结果 ALeXaLEC

zfill():返回指定长度的字符串，原字符串右对齐，前面填充0

s="alEx Alec" ret=s.zfill(11) print(ret) # 输出结果 00alEx Alec

ljust(width[, fillchar])：使用fillchar填充在字符串S的右边，使得整体长度为width。如果不指定fillchar，则默认使用空格填充。

>>> print('xyz'.ljust(5,'_')) xyz__

rjust(width[, fillchar])：使用fillchar填充在字符串S的左边，使得整体长度为width。如果不指定fillchar，则默认使用空格填充。

>>> print('xyz'.rjust(5,'_')) __xyz

列表（list）

创建：直接创建  L = [ ]

内置方法

list.append(obj)：在列表末尾添加新的对象

list1 = ['Google', 'Runoob', 'Taobao'] list1.append('Baidu') print ("更新后的列表 : ", list1) 更新后的列表 : ['Google', 'Runoob', 'Taobao', 'Baidu']

list.count(obj)：统计某个元素在列表中出现的次数

aList = [123, 'Google', 'Runoob', 'Taobao', 123]; print ("123 元素个数 : ", aList.count(123)) print ("Runoob 元素个数 : ", aList.count('Runoob')) 123 元素个数 : 2 Runoob 元素个数 : 1

list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

list1 = ['Google', 'Runoob', 'Taobao'] list2=list(range(5)) # 创建 0-4 的列表 list1.extend(list2) # 扩展列表 print ("扩展后的列表：", list1) 扩展后的列表： ['Google', 'Runoob', 'Taobao', 0, 1, 2, 3, 4]

list.index(obj)：从列表中找出某个值第一个匹配项的索引位置

list1 = ['Google', 'Runoob', 'Taobao'] print ('Runoob 索引值为', list1.index('Runoob')) print ('Taobao 索引值为', list1.index('Taobao')) Runoob 索引值为 1 Taobao 索引值为 2

list.insert(index, obj)：将对象插入列表

list1 = ['Google', 'Runoob', 'Taobao'] list1.insert(1, 'Baidu') print ('列表插入元素后为 : ', list1) 列表插入元素后为 : ['Google', 'Baidu', 'Runoob', 'Taobao']

list.pop([index=-1])：移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

list1 = ['Google', 'Runoob', 'Taobao'] list1.pop() print ("列表现在为 : ", list1) list1.pop(1) print ("列表现在为 : ", list1) 列表现在为 : ['Google', 'Runoob'] 列表现在为 : ['Google']

list.remove(obj)：移除列表中某个值的第一个匹配项

子主题

list1 = ['Google', 'Runoob', 'Taobao', 'Baidu'] list1.remove('Taobao') print ("列表现在为 : ", list1) list1.remove('Baidu') print ("列表现在为 : ", list1) 列表现在为 : ['Google', 'Runoob', 'Baidu'] 列表现在为 : ['Google', 'Runoob']

list.reverse()：反向列表中元素

list1 = ['Google', 'Runoob', 'Taobao', 'Baidu'] list1.reverse() print ("列表反转后: ", list1) 列表反转后: ['Baidu', 'Taobao', 'Runoob', 'Google']

list.sort( key=None, reverse=False)：对原列表进行排序

aList = ['Google', 'Runoob', 'Taobao', 'Facebook'] aList.sort() print ( "List : ", aList) List : ['Facebook', 'Google', 'Runoob', 'Taobao']

list.clear()：清空列表

list1 = ['Google', 'Runoob', 'Taobao', 'Baidu'] list1.clear() print ("列表清空后 : ", list1) 列表清空后 : []

list.copy()：复制列表

list1 = ['Google', 'Runoob', 'Taobao', 'Baidu'] list2 = list1.copy() print ("list2 列表: ", list2) list2 列表: ['Google', 'Runoob', 'Taobao', 'Baidu']

列表的切片：同字符串

列表得嵌套

>>>a = ['a', 'b', 'c'] >>> n = [1, 2, 3] >>> x = [a, n] >>> x [['a', 'b', 'c'], [1, 2, 3]] >>> x[0] ['a', 'b', 'c'] >>> x[0][1] 'b'

字典（dict）

字典的创建：键值对  值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

d = {key1 : value1, key2 : value2 }

内置方法

dict.clear()：删除字典内所有元素

dict = {'Name': 'Zara', 'Age': 7}; print "Start Len : %d" % len(dict) dict.clear() print "End Len : %d" % len(dict) Start Len : 2 End Len : 0

dict.copy()：返回一个字典的浅复制

dict1 = {'Name': 'Zara', 'Age': 7}; dict2 = dict1.copy() print "New Dictinary : %s" % str(dict2) New Dictinary : {'Age': 7, 'Name': 'Zara'}

dict.fromkeys(seq[, val])：创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值

seq = ('Google', 'Runoob', 'Taobao') dict = dict.fromkeys(seq) print "新字典为 : %s" % str(dict) dict = dict.fromkeys(seq, 10) print "新字典为 : %s" % str(dict) 新字典为 : {'Google': None, 'Taobao': None, 'Runoob': None} 新字典为 : {'Google': 10, 'Taobao': 10, 'Runoob': 10}

dict.get(key, default=None)：返回指定键的值，如果值不在字典中返回default值

dict = {'Name': 'Runoob', 'Age': 27} print "Value : %s" % dict.get('Age') print "Value : %s" % dict.get('Sex', "Never") Value : 27 Value : Never

dict.has_key(key)：如果键在字典dict里返回true，否则返回false

dict = {'Name': 'Zara', 'Age': 7} print "Value : %s" % dict.has_key('Age') print "Value : %s" % dict.has_key('Sex') Value : True Value : False

dict.items()：以列表返回可遍历的(键, 值) 元组数组

dict = {'Google': 'www.google.com', 'Runoob': 'www.runoob.com', 'taobao': 'www.taobao.com'} print "字典值 : %s" % dict.items() # 遍历字典列表 for key,values in dict.items(): print key,values 字典值 : [('Google', 'www.google.com'), ('taobao', 'www.taobao.com'), ('Runoob', 'www.runoob.com')] Google www.google.com taobao www.taobao.com Runoob www.runoob.com

dict.keys()：以列表返回一个字典所有的键

dict = {'Name': 'Zara', 'Age': 7} print "Value : %s" % dict.keys() Value : ['Age', 'Name']

dict.setdefault(key, default=None)：和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

dict = {'runoob': '菜鸟教程', 'google': 'Google 搜索'} print "Value : %s" % dict.setdefault('runoob', None) print "Value : %s" % dict.setdefault('Taobao', '淘宝') Value : 菜鸟教程 Value : 淘宝

dict.update(dict2)：把字典dict2的键/值对更新到dict里

dict = {'Name': 'Zara', 'Age': 7} dict2 = {'Sex': 'female' } dict.update(dict2) print "Value : %s" % dict Value : {'Age': 7, 'Name': 'Zara', 'Sex': 'female'}

dict.values()：以列表返回字典中的所有值

dict = {'Name': 'Zara', 'Age': 7} print "Value : %s" % dict.values() Value : [7, 'Zara']

pop(key[,default])：删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值。

site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'} pop_obj=site.pop('name') print pop_obj # 输出：菜鸟教程

popitem()：返回并删除字典中的最后一对键和值。

site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'} pop_obj=site.popitem() print(pop_obj) print(site) ('url', 'www.runoob.com') {'alexa': 10000, 'name': '\xe8\x8f\x9c\xe9\xb8\x9f\xe6\x95\x99\xe7\xa8\x8b'}

布尔（boor）

两个值：True  、False

判定：为False ：None、False、数字0、空列表[]、空字典{}、空元祖()，其余为True      (数字1为 True )

布尔运算

x or y :如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。

and

x and y :如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。

not

not x :如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。