python基础(5)---整型、字符串、列表、元组、字典内置方法和文件操作介绍
对于python而言,一切事物都是对象,对象是基于类创建的,对象继承了类的属性,方法等特性
1.int
首先,我们来查看下int包含了哪些函数
# python3.x
dir(int)
# ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes'] # python 2.x
dir(int)
# ['__abs__', '__add__', '__and__', '__class__', '__cmp__', '__coerce__', '__delattr__', '__div__', '__divmod__', '__doc__', '__float__', '__floordiv__', '__format__', '__getattribute__', '__getnewargs__', '__hash__', '__hex__', '__index__', '__init__', '__int__', '__invert__', '__long__', '__lshift__', '__mod__', '__mul__', '__neg__', '__new__', '__nonzero__', '__oct__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdiv__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'imag', 'numerator', 'real']
# __abs__() 绝对值输出
num = 1
result = num.__abs__() print(result) num = -1
result = num.__abs__()
print(result)
__abs__() 绝对值输出
1 num = -1
2 result = num.__add__(2)
3
4 print(result)
5
6 # 打印结果将输出 1
__add__加法
1 num = 5
2 result = num.__and__(2)
3 print(result)
4
5 #打印输出为0
6 # 0 0 0 0 0 1 0 1 5
7 # 0 0 0 0 0 0 1 0 2
8 #相同位为1则为1,由于没有相同位,所以5 & 2结果为0
__and__ 与&运算
1 # 以下结果输出都是True
2 num = 11
3 print(num.__bool__()) # True
4
5 num = -11
6 print(num.__bool__()) #True
7
8 # 以下结果输出都是 False
9 num = 0
10 print(num.__bool__()) #False
11
12 num = None
13 num = False
14 print (num.__bool__()) # False
__bool__ 布尔值
#通过divmod函数可以实现将一个int类型对象除以另一个int对象得到一个两个元素的列表,
#列表左边为除尽取整的值,第二个元素为取模的余数 num = 9
result = num.__divmod__(2)
print(result) #输出(4,1)
__divmod__ 除法取整取模
num = 2
result = num.__eq__(3)
print(result) #打印结果为False
#2 == 3 结果为假 result = num.__eq__(2)
print(result)
#打印结果为True
# 2 == 2 结果为真 __eq__ ==比较运算符
__eq__ ==比较运算符
num = 9
print(num.__float__()) #打印结果为 9.0
__float__ 转换为浮点数
num = int(181)
result = num.__floordiv__(9)
print(result) #打印输出20
#地板除 //取整 __floordiv__地板除//
__floordiv__地板除//
num = int(181)
result = num.__getattribute__("bit_length")
print(result) #打印输出 <built-in method bit_length of int object at 0x100275020>
#说明该数据类型num存在bit_length这个属性,可以用于判断对象是否拥有某种属性
__getattribute__获取对象属性
num = int(181)
print(num.__ge__(111))
#打印输出结果为True
#因为181大于111,所以结果为真,该属性用于判断大于等于该属性自身的方法,结果将返回真,否则为假
__ge__ 比较运算>=
num = 181
print(int.__invert__(num))
#打印输出-182 num = -180
print(int.__invert__(num))
#打印输出179 num = -181
print(int.__invert__(num))
#打印输出180
__invert__ 非~运算
num = -181
result = num.__le__(111)
print(result)
#打印输出结果为True
#当传人参数与对象本身相比较,只要对象小于或者等于传人的参数,则结果为真,否则为假
__le__ 小于等于
num = -181 result = num.__lshift__(1)
print(result)
#打印输出结果为-362 ,即-181 *( 2**1) result = num.__lshift__(2)
print(result)
#打印输出结果为-724 ,即-181*(2**2) #当传入参数大于等于0时且对象本身不能为0,首先参数本身为2的指数幂运算,然后再与对象本身相乘结果则为左移最终结果
__lshift__左移运算
num = -181
print(num.__lt__(11)) #打印输出结果为True #凡是对象比传入的参数小,则结果为真,否则结果为假
__lt__小于
num = -181
print(num.__mod__(3)) #打印输出结果为2,因为-181除以3等于60,余数为2,所以结果为2
__mod__取模运算
num = 181
print(num.__mul__(2)) #打印输出结果为362,即181*2的结果
__mul__ 乘法运算
num = -181
print(int.__neg__(num)) #打印结果为181,即-(-181),结果为181
__neg__一元运算减法
num = 181
print(num.__ne__(181))
#打印结果为False print(num.__ne__(11))
#打印结果为True #凡是传入参数与对象本身不相等,则结果为真,否则为假
__ne__ 不等于比较
num = 18
print(num.__or__(7)) #打印输出结果为23
# 0 0 0 1 0 0 1 0 18
# 0 0 0 0 0 1 1 1 7
# 0 0 0 1 0 1 1 1 23
位的或运算,凡是相同位有一位为真,即为1,则结果为真,即1,然后所以最终结果为23
__or__ 或|运算
num = 9
print(num.__pow__(2))
#打印输出结果为81,即9**2
__pow__ 幂运算
num = 6
print(num.__rdivmod__(3))
#返回结果(0,3) 左边为余数,右边为整除的结果
__rdivmod__ 与divmod返回的结果相反
#python 2.7
num = 1
print(num.__sizeof__())
#打印输出结果为24个字节,说明一个int类型默认就在内存中占用了24个字节大小 #python3.5
num = 1
print(num.__sizeof__())
#打印输出结果为28个字节,说明一个int类型数据默认在内存中占用了24个字节大小
__sizeof__ 计算数据类型占用内存大小
num = int(1111)
result = num.__str__()
print(type(result)) #打印输出结果为<class 'str'>
#将int类型转换为str数据类型
__str__ int转换成str
num = int(9)
print(num.__sub__(2)) #打印输出结果为7
#对象本身减去传入参数,得到最终的返回值
__sub__ 减法运算
num = 11
print(num.__truediv__(3)) #打印输出结果为3.6666666666666665
#返回的数据类型为float,浮点型
__truediv__ 真除
num = 10
print(num.__xor__(6)) # 0 0 0 0 1 0 1 0 10
# 0 0 0 0 0 1 1 0 6
# 0 0 0 0 1 1 0 0 12 #同位比较,都是0则为假,都是1则为假,一真一假为真
__xor__ 异或^运算
num = 5
print(num.bit_length())
#打印输出结果为3 # 0 0 0 0 0 1 0 1 #长度为3位
bit_length 显示数据所占位长度
num = 2.3 - 2.5j
result = num.real #复数的实部
print(result) #打印输出2.3
result = num.imag #复数的虚部
print(result) #打印输出2.5j result = num.conjugate() #返回该复数的共轭复数
print(result) #打印输出(2.3+2.5j)
conjugate
num = 5
print(num.__format__(""))
#表示5前面讲话有20个空格
__format__ 格式化输出
print(int.from_bytes(bytes=b'', byteorder='little') #打印输出 49 ,即将字符1转换为十进制
from_bytes 字符转换十进制
num = 2
result = num.to_bytes(5,byteorder='little')
print(result)
#打印输出b'\x02\x00\x00\x00\x00'
for i in result:
print(i) #打印输出2\n0\n0\n0\n0
#\n表示回车
to_bytes int转换为字节
2.str
1 #python3.5
2 dir(str)
3 #['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
4
5 #python2.7
6 dir(str)
7 #['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
strA = "hello"
print(strA.__add__(" world"))
#输出hello world
__add__ 字符串拼接
strA = "hello"
print(strA.__contains__("h"))
#True print(strA.__contains__('hex'))
#False
__contains__ 包含判断
strA = "hello"
print(strA.__eq__('hello'))
#True print(strA.__eq__('hellq'))
#False
__eq__ 字符串==比较
strA = "hello"
print(strA.__getattribute__('__add__'))
#<method-wrapper '__add__' of str object at 0x101d78730> #判断对象是否包含传入参数的属性
__getattribute__获取对象属性
strA = "hello"
print(strA.__getitem__(0))
#输出下标为0的字符 h
#超出下标会报错的
__getitem__获取对应字符
strA = "hello"
print(strA.__getnewargs__())
#打印输出 ('hello',)
#将字符类型转换为元组方式输出
__getnewargs__转换成元组
strA = "hello"
print(strA.__ge__('HELLO'))
print(strA.__ge__('Hello'))
print(strA.__ge__('hello'))
#以上结果都为True,
print(strA.__ge__('hellq'))
#以上结果为假
__ge__ 字符串比较
strA = 'Hello'
print(strA.__gt__('HellO'))
#打印输出True #字符串比较的是传入的参数每个字符首先得包含对象,其次如果字符串之间比较,大写比小写大,,如果传入参数都为大写,且对象也都为大写,那么结果为假,字符串比较首先比较的是字符串是否相同,不相同则为假,再次每个字符进行比较,只要前面有一位大于对方,则不继续比较了 #比如 HelLo与HEllo,首先两个字符串都是一样的,然后再比较第一位,第一位也一样,再比较第二位,大写比小写大,所以第二个字符串大,就不会继续比较下去了
__gt__ 字符串大于判断
strA = "hello"
print(strA.__hash__())
#-7842000111924627789
__hash__ 生成一个临时的hash值
strA = "hello"
result = strA.__iter__()
for i in result:
print(i) #打印输出
#h
#e
#l
#l
#o
__iter__ 字符串迭代
strA = 'hello'
print(strA.__len__()) #打印输出结果为5
__len__ 判断字符串长度
strA = 'Hello'
print(strA.__le__('ello'))
#True #字符串小于运算比较,先比较对象是否包含传入参数,当包含则再比较相同位的字母,大小字母比小写字母大,当前面有一位比较出谁大谁小了,则不再继续比下去了 __le__小于等于
strA = 'hello'
print(strA.__lt__('ello'))
#True #字符串小于比较与小于等于比较类似,唯一一点是小于比较时,对象与传入的参数大小写不能完全一样 __lt__ 小于
strA = 'hello'
print(strA.__mul__(3))
#hellohellohello #打印结果将输出三个hello __mul__ 乘法运算
__le__小于等于
strA = "hello" print(strA.__ne__('HEllo'))
#True #字符串不等于运算比较,凡是对象与传入参数只要有一个字母大小写不一样则为真,否则为假
__ne__ 不等于比较
strA = "HELLO"
print(strA.zfill(6))
#0HELLO #当传入的参数长度比对象长度大时,多余的长度则以0进行填充
zfill 以0填充
strA = "hELlo1112123"
print(strA.upper())
#HELLO #将所有的字母转换为大写
upper 字母转换大写
print("hello world".title()) #Hello World #每个单词首字母大写输出,且单词的第二位后面都会变成小写,如helLO,最终会格式化为Hello
title 标题
print("hEllO".swapcase())
#HeLLo #将原来的大小字母转换成小写字母,小写转换成大小字母
swapcase 大小写转换
print(" hello world ".strip())
#hello world
#将字符串两边的空格去掉
strip 去除字符串两边的空格
print("hello".startswith('h'))
#True print("hello".startswith('h',1))
#False #startswith这个函数可以指定起始位置进行判断字符是否存在
startswith 字符串是否存在该字符
print("hello\nworld".splitlines())
#['hello','world'] #splitlines默认以\n换行符进行分割字符,最终返回一个列表
splitlines 以换行符分割字符串
print("hello world".split())
#['hello','world'] print("hello world".split('\n'))
#['hello world',] #默认以空格分割字符串,可以指定分隔符
split 默认以空格分割字符
print(" hello world ".rstrip()) # hello world
#打印将会把world后面的空格去除
rstrip 去除右边的空格
print("hello world".rpartition('he'))
#('', 'he', 'llo world ')
#只返回传入参数且存在字符串里的字符然后组合成一个新的元组
rpartition 返回字符串的一部分
print("hello world".rjust(20))
# hello world
#默认以空格填充,从左到最后一个单词d结尾一个长度为20,也就是说h前面有9个空格 print("hello world".rjust(20,'+'))
#+++++++++hello world
#这里以‘+’填充,对比上面,可以看的更具体,前面有9个+被用来填充
rjust 向右偏移
print("hello world".rindex('wo'))
#
#通过查找字符串'wo'获取该字符串在hello world 里面的下标位置,这里从左往右数,第七个位置,字符串的下标默认从0开始,所以返回6
#当找不到时则抛出异常
rindex 查找下标
strA = 'hello 123'
table1 = str.maketrans('','我很好')
print(strA.translate(table1))
#hello 我很好 #将字符串里面的123通过table进行翻译成对应的值,table1的123长度必须和‘我很好长度对应’ strA = 'hello 12'
table1 = str.maketrans('','我很好')
print(strA.translate(table1))
#hello 我很
translate 翻译
print("hello".rfind('e'))
# print("hello".rfind('ee'))
#-1 如果找到,则结果为对应的下标,否则返回-1
rfind 从左到右查找
print('hello world'.replace('e','o'))
#hollo world
#将字符串里面所有的e替换成o,区分大小写
replace 字符串替换
print('hello world'.rpartition('el'))
#('h', 'el', 'lo world')
#效果与rpartition相似
partition 截取字符串
table1 = str.maketrans('','我很好')
print(table1)
#{49: 25105, 50: 24456, 51: 22909}
#首先传入的必须是两个参数,且长度相等
#返回结果将是一个字典类型,每一个字符串将会映射到第二个参数的相同位置的字符串上,
#当这里存在三个参数时,第三个参数必须是一个字符串类型,且整个字符串将被映射成None strA = 'hello 1233飒飒'
table1 = str.maketrans('','我很好','飒飒')
print(strA.translate(table1))
print(table1) #以下为输出结果
#hello 我很好好
#{49: 25105, 50: 24456, 51: 22909, 39122: None} #这个字典的值将被映射成unicode值,如49表示unicode的1
maketrans 翻译表
print(" hello world ".lstrip())
#hello world
将hello左边空格去除
lstrip 去除左边的空格
print("HELLo22".lower())
#hello22
#将所有字母转换为小写
lower 转换小写
print("hello world".ljust(20,'+'))
#hello world+++++++++
#从右向左开始进行填充,总长度为20
ljust 右填充
print('+'.join(('hello','world')))
#hello+world
#通过一个字符串去与join里面的一个迭代器里的字符串进行联结生存一个新的字符串
join 生存一个字符串
print('Hello'.isupper())
print('HELLO1'.isupper())
#False
#True #判断所有的字母是否都是大小,是则返回真,否则假
isupper 是否全部大小
print('Hello'.istitle())
print('Hello world'.istitle())
#True
#False
#判断每个单词首字母是否大写,是则为真,否则为假
istitle 是否是标题
print(' hello'.isspace())
print(' '.isspace())
#False
#True
#判断内容是否为空格
isspace 是否是空格
print('hello world'.isprintable())
print('\n'.isprintable())
#True
#False
#由于换行符是特殊字符,不可见,所以不能被打印,结果为假
issprintable 是否可以被打印
print(''.isnumeric())
print('壹'.isnumeric())
print('1q'.isnumeric())
#True
#True
#False
#True包含unicode数字,全角数字(双字节),罗马数字,汉字数字
isnumeric 是否是数字
print('Hello'.islower())
print('hello'.islower())
#False
#True
#判断字母是不是都是小写,是则为真,否则为假
islower 是否是小写
print('def'.isidentifier())
print('hello'.isidentifier())
print('2a2'.isidentifier())
#True
#True
#False #用来检测标识符是否可用,也就是说这个名字能不能用来作为变量名,是否符合命名规范,如果符合则为真
#通常会结合keyword.iskeyword()这个方法去在做判断是否是关键字,防止因命名不规范导致某些内置功能不可用
isidentifier
print('hello'.isdigit())
print('111e'.isdigit())
print('壹'.isdigit())
print(''.isdigit()) #False
#False
#False
#True #unicode数字,全角数字(双字节),byte数字,罗马数字都为真
isdigit 是否是数字
print(''.isdecimal())
print('壹'.isdecimal())
print('11d'.isdecimal())
#
#True
#False
#False
#只有全部为unicode数字,全角数字(双字节),结果才为真
isdecimal 是否是数字
print('hee'.isalpha())
print('Hello'.isalpha())
print(''.isalpha())
print('hhee1'.isalpha())
#True
#True
#False
#False
#当结果都是字母则为真,否则为假
isalpha 是否是字母
print('hew11'.isalnum())
print('HHH'.isalnum())
print(''.isalnum())
print(' q '.isalnum())
print('!!@~d'.isalnum())
#True
#True
#True
#False
#False #当结果为任意数字或字母时,结果为真,其他字符为假
isalnum 是否为数字或字母
print('hello'.index('e'))
print('hello'.index('el'))
print('hello'.index('el',1))
#
#
#
#通过查找制定的字符获取对应字符串的下标位置,可以指定起始位置,第3个事咧则表示从下标1开始查找,包括下标1的位置,如果指定end的结束位置,查找是不包括end的位置本身
index 通过字符查找下标
print('hello'.find('h',0))
print('hello'.find('h',1))
#
#-1 #find是从下标0位置开始找起,包含开始的位置0,如果有结束的位置,不包含结束位置,查找到则显示具体下标位置,否则显示-1
find查找字符串下标
print('hello{0}'.format(' world'))
print('hello{0}{1}'.format(' world',' python'))
print('hello{name}'.format(name=' world'))
#hello world
#hello world python
#hello world
format 格式化输出字符串
print('hello\tworld'.expandtabs(tabsize=8))
#hello world 指定制表符长度为8
expandtabs 制表符长度
print('hello'.endswith('lo',3))
#True
#判断结束字符是否为lo,默认从下标0开始查找,包含下标0的位置
endswith 判断结束字符
print('我好'.encode())
print('hello'.encode())
# print('hela!~@@~!\xe2lo'.encode('gbk',errors='strict'))
print(b'\xe6\x88\x91\xe5\xa5\xbd'.decode('utf-8')) #b'\xe6\x88\x91\xe5\xa5\xbd'
#b'hello'
#我好 #将字符串进行编码,最终返回以b开头的编码格式
encode 编码
print('heelloe'.count('e',1,2))
#
#表示从开始下标1包括下标1位置查找字符e,结束位置为下标2,不包括结束位置
#统计结果为1
count 统计相同的字符
print('aaa'.center(22,'+'))
#+++++++++aaa++++++++++
#表示将字符aaa的位置显示在长度为22的中间位置,默认是空格方式填充,这里以+号填充方便演示效果,注意,由于22-3(字符本身3个长度),剩余的并不能整除,所以先整除的整数部分作为公共的填充内容,剩余的填充到末尾
center 中心显示
print('hDasdd23ellAo'.casefold())
#hdasdd23ellao #将字符串里面所有的字母都转换为小写输出
casefold 字母转换小写
print('hEello World'.capitalize()) #Heello world
#这个方法会将整个字符串的第一个字母大写,其余都是小写输出,如果第一个字符串不是字母,则只将其余字母转换成小写
capitalize 首字母大写
3.list
#定义一个列表
b = ['a','hello','python','']
#查看列表的内置方法
dir(b)
# 2.x 输出 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'] # 3.x输出['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'] b.append('tail') #在列表末尾追加一个元素'tail'
b.count('python') #统计列表中有多少个相同的元素'python'
b.extend('how') #在列表后面追加三个字符串'h','o','w'
b.index('python') #显示元素‘python’的索引,这里将输出2
b.insert(1,'niubi') #在索引为的位置插入元素'niubi',及原来的元素从1往后加1
b.pop() #将列表最后一个元素删除
b.remove('niubi') #删除指定元素,即,将指定的'niubi'元素删除
b.reverse() #将列表的元素由原来的从左到右顺序变成从右到左方式排序
b.sort() #将列表按照asscipython基础(5)---整型、字符串、列表、元组、字典内置方法和文件操作介绍的更多相关文章
- Day 08 可变与不可变对象/列表与字典内置方法
目录 可变对象与不可变对象 可变对象 不可变对象 列表的内置方法 字典内置方法 可变对象与不可变对象 可变对象 对象指向的内存中的值会改变,当更改这个变量的时候,还是指向原来内存中的值,并且在原来的内 ...
- Python基础学习笔记(八)常用字典内置函数和方法
参考资料: 1. <Python基础教程> 2. http://www.runoob.com/python/python-dictionary.html 3. http://www.lia ...
- Python 整数 长整数 浮点数 字符串 列表 元组 字典的各种方法
对于Python, 一切事物都是对象,对象基于类创建!! 注:查看对象相关成员var,type, dir 一.整数 如: 18.73.84 每一个整数都具备如下需要知道的功能: def bit_len ...
- 列表&元组的内置方法
标红为元组可以使用
- Python第三天 序列 数据类型 数值 字符串 列表 元组 字典
Python第三天 序列 数据类型 数值 字符串 列表 元组 字典 数据类型数值字符串列表元组字典 序列序列:字符串.列表.元组序列的两个主要特点是索引操作符和切片操作符- 索引操作符让我 ...
- Python第三天 序列 5种数据类型 数值 字符串 列表 元组 字典 各种数据类型的的xx重写xx表达式
Python第三天 序列 5种数据类型 数值 字符串 列表 元组 字典 各种数据类型的的xx重写xx表达式 目录 Pycharm使用技巧(转载) Python第一天 安装 shell ...
- python之字符串,列表,字典,元组,集合内置方法总结
目录 数字类型的内置方法 整型/浮点型 字符串类型的内置方法 列表的内置方法 字典的内置方法 元组的内置方法 集合类型内置方法 布尔类型 数据类型总结 数字类型的内置方法 整型/浮点型 加 + 减 - ...
- python基础-列表List及内置方法
数据类型之列表-List 用途:用于存一个或多个不同类型的值 定义:通过中括号存值,每个值之间通过逗号进行分隔 l1 = [1,'a',3,'b'] 特性:有序.可变.存多个值的数据类型 常用方法: ...
- 字符串:各种奇葩的内置方法 - 零基础入门学习Python014
字符串:各种奇葩的内置方法 让编程改变世界 Change the world by program 字符串:各种奇葩的内置方法 或许现在又回过头来谈字符串,有些朋友可能会觉得没必要,也有些朋友会觉得不 ...
随机推荐
- 模块(3)-使用__future__
使用__future__ Python的每个新版本都会增加一些新的功能,或者对原来的功能作一些改动.有些改动是不兼容旧版本的,也就是在当前版本运行正常的代码,到下一个版本运行就可能不正常了. 从Pyt ...
- SQL注入(SQL Injection)案例和防御方案
sql注入(SQL Injection):就是通过把SQL命令插入到Web表单递交或输入域名或页面请求的查询字符串,最终达到欺骗服务器执行恶意的SQL命令. SQL注入攻击的主要危害包括:非法读取.篡 ...
- spark(一)
一.spark 学习 1. spark学习的三种地方: (1)Spark.apache.org 官方文档 (2)spark的源代码的官方网站 https://github.com/apache/ ...
- mysql数据库----索引补充
1.索引 索引是表的目录,在查找内容之前可以先在目录中查找索引位置,以此快速定位查询数据.对于索引,会保存在额外的文件中. 2.索引种类 普通索引:仅加速查询 唯一索引:加速查询 + 列值唯一(可以有 ...
- C++模板类注意事项
最近使用C++模板,虽然工作几年了,但是模板用的很少,确切的说自己实现的机会很小. 昨天写了一个代码maxheap.h 中实现了类模板的声明,我将实现写在maxheap.cpp中, 当在main.cp ...
- 「Django」与mysql8连接的若干问题
1.setting配置 DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', #数据库驱动名 'NAME': 'my_tes ...
- php网摘收藏
1.thinkphp3.2.3开发手册: http://document.thinkphp.cn/manual_3_2.html 2.ThinkPHP3.2.3的函数汇总:http://www.thi ...
- [DeeplearningAI笔记]卷积神经网络3.6-3.9交并比/非极大值抑制/Anchor boxes/YOLO算法
4.3目标检测 觉得有用的话,欢迎一起讨论相互学习~Follow Me 3.6交并比intersection over union 交并比函数(loU)可以用来评价对象检测算法,可以被用来进一步改善对 ...
- OpenCV---图像金字塔原理
图像金字塔原理 (一)图像缩小(先高斯模糊,再降采样,需要一次次重复,不能一次到底) (二)图像扩大(先扩大,再卷积或者使用拉普拉斯金字塔) 图像金字塔介绍 图像金字塔是图像中多尺度表达的一种,最主要 ...
- CSS3方法总汇
PS:CSS3的3D和我做研发时的3D不一样他们只能旋转180度 横为X竖为Z高为Y transfrom:2D3D转换 rotareX:绕着X轴旋转 rotareY(-180deg):绕着Y轴旋转- ...