初识python第二天（3）

我们接着上一篇博客，继续来来了解Python一些常见类的函数使用方法

一.int

# 运算符，>=，比较self是否大于等于value,只要满足大于或者等于其中一个条件，就返回True,否则就返回False

num = 8   
result = num.__ge__(6)
print(result)
#结果输出  True

num = 8   
result = num.__ge__(8)
print(result)
#结果输出  True

# 获取对象属性，如果存在就返回该对象属性，否则就报错，一般需要与hassttr一同使用
num = 8
print(hasattr(num, '__add__'))  #使用hasattr对象是否有__add__这个函数存在

result = num.__getattribute__('__add__')   
print(result)
#打印输出<method-wrapper '__add__' of int object at 0x0000000059BA39B0>
# 获取对象属性，如果存在就返回该对象属性，否则就报错，一般需要与hassttr一同使用

num = -9    
result = num.__invert__()
print(result)
#结果输出 8

num = 9    
result = num.__invert__()
print(result)
#结果输出-10

num = 90
result = num.__invert__()
print(result)
#结果输出  -91

 # 比较运算符，用于比较self与vlaue是否小于等于，如果小于或等于就返回结果为True，否则就为False

num = 8     
result = num.__le__(9)
print(result)
#结果输出  True

num = 8     
result = num.__le__(8)
print(result)
#结果输出  True

# 左移运算，value参数几就表示像左移几位
num = 8    
result = num.__lshift__(2)
print(result)
# 0 0 0 0 1 0 0 0    8
# 0 0 1 0 0 0 0 0    32
#结果输出  32

# 比较运算，小于，判断self是否小于value，如果小于就返回结果为True,否则就为False

num = 8  
result = num.__lt__(9)
print(result)
#结果输出  True

 # 取模运算，将得到的结果的余数返回

num = 9  
result = num.__mod__(4)
print(result)

#结果输出 1

num = 8   
result = num.__mul__(4)
print(result)

#结果输出 32

# 算术运算，判断两个对象是否不相等，如果不相等，就返回结果为True,否则返回结果为False
num = 8   
result = num.__ne__(9)
print(result)
#结果输出 True

num = 8   
result = num.__ne__(8)
print(result)
#结果输出 False

#一元运算减法，返回对象相反的结果

num = 90  
result = num.__neg__()
print(result)
#结果输出  -90

num = -90  
result = num.__neg__()
print(result)
#结果输出  90

# 位的或运算，当凡相同位为真，即为1，则结果为真，即1，所以结果为9

num = 8    
result = num.__or__(9)
print(result)
# # 0 0 0 0 1 0 0 0     8
# # 0 0 0 0 1 0 0 1     9
#结果输出  9

#幂运算，即8**2次方
num = 8    
result = num.__pow__(2)
print(result)

#结果输出  64

 #  加法，value+self
num = 8 
result = num.__radd__(9)
print(result)

#输出结果  17

#与&运算，相同位1则为1，返回结果相同位相加，不相同则为零
num = 8   
result = num.__rand__(9)
print(result)

#结果输出  8
# 0 0 0 0 1 0 0 0
# 0 0 0 0 1 0 0 1

num = 8
print(num.__or__(7))
#结果输出  15
# 0 0 0 0 1 0 0 0   8
# 0 0 0 0 0 1 1 1    7
# 0 0 0 0 1 1 1 1     15
#位的或运算，只要相同位为真就为真，即为1，则结果为真，所以最终结果为15

#__rdivmod与divmod的结果相反
num = 9
print(num.__rdivmod__(3))

#结果输出 (0, 3)
#返回的结果（0，3），左边为余数，右边为整除的结果

num = 7
print(num.__sizeof__())

#结果输出为28个字节，

num = 8
result = num.__str__()
print(type(result))

#结果输出  <class 'str'>
#将int数据类型转换为str数据类型

num = 8
print(num.__sub__(6))
#结果输出  2
#对象本身减去传入的参数，得到最终的返回值

#真除，返回的数据类型为float，浮点型
num = 8
print(num.__truediv__(2))  #结果输出  4.0

num = 8
print(num.__truediv__(3))  
#结果输出  2.6666666666666665

num = 8
print(num.__xor__(4))
#结果输出 12

# 0 0 0 0 1 0 0 0    8
# 0 0 0 0 0 1 0 0    4
# 0 0 0 0 1 1 0 0   12
#同位比较，都是0则为假，都是1则为假，一真一假则为真

num = 8
print(num.bit_length())

#结果输出为4

# 0 0 0 0 0 1 0 0 #长度为4

num = 2.3 - 2.5j
result = num.real     #复数的实部
print(result)              #打印输出2.3
result = num.imag    #复数的虚部
print(result)               #打印输出2.5

result = num.conjugate()     #返回该复数的共轭复数
print(result)     #打印输出 (2.3+2.5j)

print(int.from_bytes(bytes=b'3', byteorder='little'))

#打印输出51，即将字符3转换为十进制

num = 8
result = num.to_bytes(3, byteorder='little')
print(result)
#打印输出 b'x08x00x00'

for i in result:
    print(i)

#打印输出
8
0
0

二.str

#python 3.x
print(dir(str))
#['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__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']

#python 2.x
dir(str)
#['__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']

a = 'hello'
print(a.__add__(' world'))

#输出结果 hello world

#用来判断参数是否在对象中，如果存在就返回True，不存在就返回False

name = 'LaiYing'
print(name.__contains__('ai'))
#结果输出 True 

name = 'LaiYing'
print(name.__contains__('x'))
#结果输出False

#__eq__,用来比较对象与参数的字符串是否相同，如果相同就返回True,否则就返回False
name = 'jack'
print(name.__eq__('jack'))
#结果输出 True

name = 'jack'
print(name.__eq__('Jack'))
#结果输出False

#用来判断对象是否包含传入参数的属性，一般与hasattr配合使用
name = 'LaiYing'
print(hasattr(name, '__add__'))  #先使用hasattr查看对象是否有这个属性
print(name.__getattribute__('__add__'))

#结果输出<method-wrapper '__add__' of str object at 0x00000000006AF1F0>

#获取对应字符，下标从0开始，传的参数如果超出下标会报错
name = 'LaiYing'   
print(name.__getitem__(2))

#输出下标为2的字符  i

name = 'LaiYing'
print(name.__getnewargs__())
#结果输出 ('LaiYing',)
#将字符类型转换为元组输出

#判断传入的参数和对象的内容是否相同，字符串不区分大小写，如果相同就返回True,否则就返回False
name = 'laiying'
print(name.__ge__('LAIYING'))   #结果输出 True
print(name.__ge__('LaiYING'))    #结果输出 True
print(name.__ge__('laiying'))      #结果输出 True

print(name.__eq__('laiyinghh'))  #结果输出为假

strA = 'Hello'
print(strA.__gt__('HellO'))
#打印输出True
 
#字符串比较的是传入的参数每个字符首先得包含对象，其次如果字符串之间比较，大写比小写大，，如果传入参数都为大写，且对象也都为大写，那么结果为假,字符串比较首先比较的是字符串是否相同，不相同则为假，再次每个字符进行比较，只要前面有一位大于对方，则不继续比较了
 
 #比如 HelLo与HEllo,首先两个字符串都是一样的，然后再比较第一位，第一位也一样，再比较第二位，大写比小写大，所以第二个字符串大，就不会继续比较下去了

name = 'laiying'
print(name.__hash__())

#结果输出 -1321548470539019197

name = 'lai'   
result = name.__iter__()
for i in result:
    print(i)

#结果输出
# l
#a 
# i

name = 'LaiYing'  
print(name.__len__())

#打印输出结果 7

name = 'LaiYing'   
print(name.__le__('Ying'))
#结果输出 True
#字符串小于运算比较，先比较对象是否包含传入参数，当包含则再比较相同位的字母，大小字母比小写字母大，当前面有一位比较出谁大谁小了，则不再继续比下去了

name = 'laiying'  
print(name.__ne__('LaiYing'))
#结果返回True

#字符串不等于运算比较，凡是对象与传入参数只要有一个字母大小写不一样则为真，否则为假

name = 'laiying'
print(name.zfill(8))
#结果显示 0laiying

#当传入的参数长度比对象长度大时，多余的长度则以0进行填充

#将所有字母转换为大写

name = 'laiying'
print(name.upper())
#结果输出 LAIYING

#标题，将首字母大小，并默认把其他字母小写
name = 'hello world'  
print(name.title())

#结果输出 Hello World
#将每个单词的首字母大写输出，且首字母后的单词都会变成小写，如hELLo，最终会格式化为Hello

name = 'LaiYing'  
print(name.swapcase())
#结果输出  lAIyING

name = ' lai  ying   '
print(name.strip())

#结果输出  lai  ying

print('laiying'.startswith('lai'))
#输出结果Ture

print('laiying'.startswith('ai'))
#输出结果False

#startswith这个函数可以指定起始位置进行判断字符是否存在

print('hello
world'.splitlines())
#结果输出  ['hello', 'world']

#splitlines默认以
换行符进行分割字符，最终返回一个列表

print('hello word'.split())
#结果输出  ['hello', 'word']

print('hello word'.split('
'))
#结果输出  ['hello word']


#默认以空格进行分割，可以指定分割符

print('  lai  ying  '.rstrip())
#结果输出    lai  ying

#打印将会把ying后面的空格去除

print('hello world'.rpartition('ll'))
#结果输出  ('he', 'll', 'o world')
#只返回传入参数且存在字符串里的字符，然后组合成一个新的元组

print('hello world'.rjust(20))
#结果输出         hello world
#默认以空格填充，从左到最后一个单词d结尾，一个长度为20，也就是说h前面有9个空格

print('hello world'.rjust(20,'*'))

#结果输出  *********hello world
#'*'这里可以指定填充的字符，这样看着更具体，前面有9个*被用来填充

print('hello world'.rindex('r'))
#结果输出 8
#通过查找字符'r'，获取字符串在hello world里面的下标位置，这里从左往右数，第8个位置，字符串的下标默认从0开始，当找不到时则抛出异常

a = 'hello 12'
table1 = str.maketrans('12','赖英')
print(a.translate(table1))
#结果输出 hello 赖英

#将字符串里面的12通过table进行翻译成对应的值，table的12长度必须和‘赖英’长度对应

a = 'hello 12' #翻译
table1 = str.maketrans('123','赖英好')
print(a.translate(table1))
#结果输出 hello 我很

print('laiying'.find('i'))
#输出结果 2

print('laiying'.rfind('i'))
#结果输出  4

print('laiying'.rfind('ii'))
#结果输出 -1
#如果找到，则结果为对应的下标，否则返回-1

print('laiying'.replace('l','y'))
#结果输出 yaiying
#将字符串里面所有的l替换为y，区分大小写

print('laiying'.rpartition('yi'))
#结果输出 ('lai', 'yi', 'ng')
#效果与partiton相似

table1 = str.maketrans('123', '你好吗')
print(table1)
#结果输出{49: 20320, 50: 22909, 51: 21527}
#首先传入的必须的两个参数，且 长度相等
#返回的结果将是一个字典类型，每一个字符串将会映射到第二个参数的相同位置的字符串上
#当这里存在三个参数时，第三个参数必须是一个字符串类型，且整个字符串将被映射成None


a = 'hello 123您好'
table1 = a.maketrans('123','你好吗', '很好')
print(a.translate(table1))
print(table1)
#结果输出，如下
#{24456: None, 49: 20320, 50: 22909, 51: 21527, 22909: None}


#这个字典的值将会被映射成unicode值，如49表示unicode的1

print('  lai ying  '.lstrip())
#结果输出 lai ying

#将lai左边的空格去除

print('HELLo WorlD'.lower())
#结果输出 hello world
#将所有字母全部转换为小写

print('hello world'.ljust(20, '*'))
#结果输出  hello world*********
#从右像左进行填充，总长度为20，可指定填充字符

print('+'.join(('hello', 'world')))
#结果输出 hello+world
#通过一个字符串去与join里面的一个迭代器里的字符串进行连接生成一个新的字符串

print('Hello'.isupper())
#结果输出False

print('HELLO'.isupper())
#结果输出 True

#判断字母是否为全是大写，如果是大写返回真，否则为假

print('Hello World'.istitle())
#结果输出  True


print('hello world'.istitle())
#结果输出 False

#判断每个单词首字母是否大写，是则为真，否则为假

#isspace判断是否为空格，是为真，否则为假
print('hello'.isspace())  
#结果输出  False


print(' '.isspace())
#结果输出True

print('hello world '.isprintable())
#结果输出 True

print('
'.isprintable())
#结果输出False

#由于换行符是特殊字符，不能被打印，所以结果为假

print('111'.isnumeric())
print('壹'.isnumeric())
print('1y'.isnumeric())

#True
#True
#False
#True包含unicode数字，全角数字（双字节），罗马数字，汉字数字

print('hello'.islower())  
#结果输出 True

print('HelLo'.islower())
#结果输出False

#判断字母是否全是小写,是为真，否则为假

print('def'.isidentifier())  
print('lai'.isidentifier())
print('2b2'.isidentifier())
#True
#True
#False

#用来检查标识符是否可用，也就是说这个名字能不能用来作为变量名，是否符合命令规范，如果符合则为真，否则为假
#通常会结合keyword.iskeyword()这个方法去做判断是否是关键字，防止因命名不规范导致某些内置功能不可用