Python运算符，基本数据类型

python开发IDE：pycharm

#专业版

1.运算符

　　结果是值

　　　　　　算术运算　　

　　　　　　　　a = 10*2

　　　　　　赋值运算

　　　　　　　　a = a + 1 a+=1

　　结果是布尔值

　　　　　　比较运算

　　　　　　　　a = 1 > 5　

　　　　　　逻辑运算

　　　　　　　　a = 1 > 6 or 1 == 1

　　　　　　成员运算

　　　　　　　　a = "过"　in "中国"　

2.基本数据类型

　数字　　int ，所有的功能都放在int里

　　　　a = 323

1.bit_length()

def bit_length(self): # real signature unknown; restored from __doc__
"""

"""返回表示该数字的二进制最少位数"""
int.bit_length() -> int

Number of bits necessary to represent self in binary.
>>> bin(37)
'0b100101'
>>> (37).bit_length()
6
"""
return 0

下面我们来看一个例子，我们知道计算机底层都是0和1表示，我们定义a = 10，看a的二进制表示方式如下：

0 0 0 0 1 0 1 0 10(二进制)

>>> bin(a)
　　'0b1010'

我们也可以使用bin()函数（bin()函数是把一个整数转化为二进制的表示形式），把一个整数转化为二进制进行查看：

那么可以看出10的二进制最少位数为4，下面使用bit_length进行验证一下：

>>> a = 10
　　>>> a.bit_length()
　　4

从上面程序我们可以看出，输出结果与我们设想的是一致的，bit_length()方法不需要参数，用来返回整数的二进制长度。

下面我们来进一步进行探讨一下，我们都学过数学，知道有正整数，负整数，浮点数(float,即小数),来看一下是否bit_length属性：

>>> a = -10
　　>>> a.bit_length()
　　4
　　>>> a = 10.5
　　>>> a.bit_length()
　　Traceback (most recent call last):
　　File "<stdin>", line 1, in <module>
　　AttributeError: 'float' object has no attribute 'bit_length'

从上面可以看出，负整数也是有bit_length属性的，但是浮点数是没有这个属性的，浮点数使用bit_length属性的时候，程序报错，提示float数没有bit_length，因此我们可以得到结论，无论正整数还是负整数都具有属性bit_length，都能用二进制进行表示在计算机里面，而且int(10)和int(-10)的二进制长度是一样的。

2.conjugate()

def conjugate(self, *args, **kwargs): # real signature unknown

"""返回一个整数的共轭复数"""
""" Returns self, the complex conjugate of any int. """
pass

>>> a = 10
　　>>> a.conjugate()
　　10

大家可以去看看共轭复数的概念，实部相等，虚部相反称为共轭复数，现在都忘的差不多了。

3.__abs__()

def __abs__(self, *args, **kwargs): # real signature unknown

# a.__abs__() 等价于 abs(a)

"""返回绝对值"""
　　""" abs(self) """
　　pass

__abs__()是返回一个数的绝对值，我们知道，肯定是用来返回复数的绝对值，正数的绝对值还是其本身，由于__abs__是处理数据的时候的常用功能，因此Python中内置了abs()函数，abs()函数在运用的时候也是调用__abs__()来实现的。下面来看两个列子：

>>> a = -19
　　>>> a.__abs__()
　　19
　　>>> abs(a)
　　19
可以看出，两个方法得到的结果是一致的，其实Python中内置的函数就是调用类中的方法，这点在我们逐渐学习的过程中会看得更深入。

3.__add__(self,y)

def __add__(self, *args, **kwargs): # real signature unknown

"""返回两个数字相加的结果"""

""" x.__add__(y)等价于x+y """
　　""" Return self+value. """
　　pass

>>> a = 5
　　>>> x = 5
　　>>> y = 3
　　>>> x.__add__(y)
　　8
　　>>> x + y
　　8
　　>>> z = 3.5
　　>>> x.__add__(z)
　　NotImplemented
　　>>> x+z
　　8.5

可以看出，两种方式是等价的，但是不知道为什么使用__add__()方法的时候，不能对浮点数进行相加，但是加号(+)是可以的，可能定制类的时候，要想相加必须是统一类的类型数字，就是在一个类中定义的方法处理的时候必须是相同的类。

def __add__(self, *args, **kwargs): # real signature unknown

"""返回两个数的位与运算符(二进制下的位与运算符)"""
　　""" Return self+value. """
　　pass

下面我们来看一下具体实例：

0 0 0 0 1 0 1 0 二进制：10

0 0 1 1 0 0 1 0 二进制：50

0 0 0 0 0 0 1 0 a.__and__(a&b)

上面是二进制下10和50的表示方法，位于运算符是同为真的时候才为真，运算结果在上面，00000010是十进制下的2，下面来看一下：

>>> a = 10
　　>>> b = 50
　　>>> a.__and__(b)
　　2
　　>>> a&b
　　2
可以看出两者的结果是一致的，我们知道&是and的缩写表示形式，所以在使用的时候使用__and__()或者&都是可以的。

4.__bool__(self)

def __bool__(self, *args, **kwargs): # real signature unknown
　　""" self != 0 """

"""判断一个值是否为True或者False"""
　　pass

我们知道在Python中True==1，False==0，我们经常使用bool值进行判断：

>>> a = 5
　　>>> b = 1.5
　　>>> c = 1
　　>>> d = 0
　　>>> a.__bool__()
　　True
　　>>> b.__bool__()
　　True
　　>>> c.__bool__()
　　True
　　>>> d.__bool__()
　　False
可以看出，0为False，只要不是0，都为真，这个性质跟Excle中函数的性质是一样的，因为我们经常要根据返回的值进行判断，判断结果是否为零。

5.__ceil__(self)

def __ceil__(self, *args, **kwargs): # real signature unknown

"""__ceil__(self)返回数字的上入整数,要是学过Excel就相当于ceiling()函数，向上舍入到最接近的整数
　　""" Ceiling of an Integral returns itself. """
　　pass

ceil() 函数返回数字的上入整数

注意：ceil()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。

import math   #导入math模块

print "math.ceil(-45.17) : ", math.ceil(-45.17)
print "math.ceil(100.12) : ", math.ceil(100.12)
print "math.ceil(100.72) : ", math.ceil(100.72)
print "math.ceil(119L) : ", math.ceil(119L)
print "math.ceil(math.pi) : ", math.ceil(math.pi)
运行结果如下：
math.ceil(-45.17: -45
math.ceil(100.12): 101
math.ceil(100.72: 101
math.ceil(119.0001: 120
math.cell(math.pi): 4
    Python中有专门处理数字的math模块，用户数学运算的处理，需要的时候可以导入math模块的功能。
    6.__divmod__(self,value)
    def __divmod__(self, *args, **kwargs): # real signature unknown
    """返回两个数相处的商和余数，放在一个元素中a.__divmod__(b)返回(商,余数)"""
    """ Return divmod(self, value). """
    pass
 我们经常访问网站，比如安居客和链家，上面有显示经纪人的房源信息，每页显示的房源信息是有最大值固定的，比如我们现在有553条房源信息，每
页可以放10条房源信息，那么需要多少页，我们知道需要55整页还剩3条房源，这3条肯定也要放一页，因此需要56个网页存放。下面我们来演示一下这个
函数：
　　>>> a = 55
　　>>> b = 60
　　>>> c = 10
　　>>> a.__divmod__(c)
　　(5, 5)
　　>>> b.__divmod__(c)
　　(6, 0)
　　>>> type(a.__divmod__(c))
　　<class 'tuple'>
    a.__divmod__(b)我们得到a与b的商和余数部分，并且存放在一个元组中，这点我们要记住，得到商和余数存放在一个元组中。
    7.__eq__(self,value)
    def __eq__(self, *args, **kwargs): # real signature unknown
    """__eq__(self,value)等价于判断 self == value，判断是否与要求的数字相等"""
    """ Return self==value. """
    pass
    __eq__()是中的eq是单词equal的缩写，equal是相等的意思，判断两个数字是否相等。如下：
    >>> a = 5
　　>>> b = 3
　　>>> c = 5
　　>>> a.__eq__(b)
　　False
　　>>> a.__eq__(c)
　　True
    判断两个数字相等，返回布尔值(bool)，如果相等返回True；否则返回False。
    8.__ne__(self,value)
    def __ne__(self, *args, **kwargs): # real signature unknown
    """判断两个数字是否不想等，如果不想等返回True；否则返回布尔值False."""
    """ Return self!=value. """
    pass
    判断两个数字是否相等，相等返回True，否则返回False。__ne__(self,value)是单词not equal的缩写，表示不等于的含义，下面我会进行总结：
    >>> a = 5
　　>>> b = 3
　　>>> c = 5
　　>>> a.__ne__(b)
　　True
　　>>> a.__ne__(c)
　　False
    从上面我们可以看出，a != b的时候返回的是True；a == c的时候返回布尔值False.
    9.__ge__(self,value)
    def __ge__(self, *args, **kwargs): # real signature unknown
    """__ge__(self,value)是用来判断self>=value，如果self大于等于要比较的value值，则返回布尔值True,否则返回False"""
    """ Return self>=value. """
    pass
    __ge__(self,value)是大于等于的含义，比较self>=value，ge是单词greater than or equal to的缩写，表示大于等于：判断如下：
    >>> a = 5
　　>>> b = 3
　　>>> c = 6
　　>>> a.__ge__(c)
　　False
　　>>> a.__ge__(b)
　　True
    10.__gt__(self,value)
    def __gt__(self, *args, **kwargs): # real signature unknown
    """__gt__(self,value)判断self是否大于给定的值value"""
    """ Return self>value. """
    pass
    判断self是否大于给定的值value,如果大于返回True;否则返回Fasle.__gt__(self,value)中的ge是单词greater than的缩写，表示大于。
    11.__le__(self,value)
    def __le__(self, *args, **kwargs): # real signature unknown
    """__le__(self,value)判断self <= value，如果条件成立返回True,否则返回False."""
    """ Return self<=value. """
    pass
    __le__(self,value)是用于判断self是否小于等于value的，如果成立返回True；否则返回False.__le__(self,value)中le是单词less than equal的缩
写，函数是小于等于。
    >>> a = 5
　　>>> b = c
　　>>> c = 6
　　>>> a.__le__(c)
　　True
　　>>> a.__le__(b)
　　True
    12.__lt__(self,value)
    def __lt__(self, *args, **kwargs): # real signature unknown
    """用于判断self<value是否成立"""
    """ Return self<value. """
    pass
    __lt__(self,value)是用来判断self是否小于给定值value，如果条件成立，则返回True；否则返回False。__lt__中lt是单词less than的缩小，表示
小于，用来比较一个数是否小于另外一个数，实例如下：
    >>> a = 5
　　>>> b = 5
　　>>> c = 6
　　>>> d = 1
　　>>> a.__lt__(b)
　　False
　　>>> a.__lt__(c)
　　True
　　>>> a.__lt__(d)
　　False
下面总结了int类中几种相似的方法，以及简写和单词含义，可以帮助我们进行记忆：


    13.__float__(self)
    def __float__(self, *args, **kwargs): # real signature unknown
    """ float(self) """
    pass
　　__float__(self)是将整数转化为浮点形数字，等价于float(a).
　　>>> a = 5
　　>>> a.__float__()
　　5.0
　　>>> float(a)
　　5.0
    14.__floordiv__(self,value)
    def __floordiv__(self, *args, **kwargs): # real signature unknown
    """ Return self//value. """
    pass
    __floordiv__(self,value)是用于self/vaule然后返回商向下的最接近的整数，floor和ceil是一对方法，一个是向上舍入最接近的整数，一个是向
下舍入最接近的整数，不是什么地板除，这个在Excel函数中有的，学过Excel函数的应该知道里面有两个数学函数ceiling向上舍入和floor向下舍入的函
数，这里是先进行除法，然后对商进行向下舍入。
    >>> a = 8
　　>>> a.__floordiv__(3)
　　2
　　>>> a = -8
　　>>> a.__floordiv__(3)
　　-3
    15.__floor__(self)
    def __floor__(self, *args, **kwargs): # real signature unknown
    """ Flooring an Integral returns itself. """
    pass
    __floor__(self)是将数字向下舍入到最接近的整数，跟上面__floordiv__(self,value)方法类似，只是不需要参数，实例如下：
    由于floor()在数学上应用的比较多，因此要使用__floor__()方法，要调用math模块。
import math
#导入math模块

print("math.floor(2.00001): %s" %math.floor(2.00001))
print("math.floor(2.9999999): %s" %math.floor(2.9999999))
print("math.floor(-2.000001: ) %s" %math.floor(-2.000001))
运行结果如下：
math.floor(2.00001): 2
math.floor(2.9999999): 2
math.floor(-2.000001: ) -3   
    16.__format__()
　　def __format__(self, *args, **kwargs): # real signature unknown
    　　pass 
    17.__getattribute__(self,*args,**kwargs)
　　def __getattribute__(self, *args, **kwargs): # real signature unknown
    　　""" Return getattr(self, name). """
        """类中的方法"""
    　　pass
    18.__getnewargs__(self,*args,**kwargs)
　　def __getnewargs__(self, *args, **kwargs): # real signature unknown
    　　pass
    19.__hash__(self,*args,**kwargs)
　　def __hash__(self, *args, **kwargs): # real signature unknown
    　　""" Return hash(self). """
    　　pass
    20.__index__(self,*args,**kwargs)
　　def __index__(self, *args, **kwargs): # real signature unknown
    　　""" Return self converted to an integer, if self is suitable for use as an index into a list. """
    　　"""返回索引，我们知道，一般列表，字符串才有索引，这里的index()没有参数，可能在math模块中使用"""
    　　pass
    21.__init__(self,x,base=10)
def __init__(self, x, base=10): # known special case of int.__init__
    """
    """__init__()叫构造方法，构造的时候经常用，构造类的时候使用这个函数"""
    int(x=0) -> integer
    int(x, base=10) -> integer
    
    Convert a number or string to an integer, or return 0 if no arguments
    are given.  If x is a number, return x.__int__().  For floating point
    numbers, this truncates towards zero.
    
    If x is not a number or if base is given, then x must be a string,
    bytes, or bytearray instance representing an integer literal in the
    given base.  The literal can be preceded by '+' or '-' and be surrounded
    by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
    Base 0 means to interpret the base from the string as an integer literal.
    >>> int('0b100', base=0)
    4
    # (copied from class doc)
    """
    pass
    22.__int__(self,*args,**kwargs)
　　def __int__(self, *args, **kwargs): # real signature unknown
    　　""" int(self) """
　　　　"""用于把字符形数字转化为整型"""
    　　pass
    23.__invert__(self,*args,**kwargs)
　　def __invert__(self, *args, **kwargs): # real signature unknown
    　　""" ~self """
    　　pass
    24.__lshift__(self,*args,**kwargs)
　　def __invert__(self, *args, **kwargs): # real signature unknown
    　　""" ~self """
    """左移运算符，向左边移动位置，按照二进制的格式移动，有一个规律，如果移动向左移动一位等于乘以2"""
    　　pass
>>> a = 50
>>> a.__lshift__(1)

0 0 0 0 1 0 1 0 二进制：10

0 0 1 1 0 0 1 0 二进制：50

0 0 1 1 1 0 1 0 a.__or__(a |b)

起始int类中的方法就像我们学习数学的时候运用的方法一样，那些方法都是使用的，比如加减乘除，冪，求余，截尾等。

　字符串 str

　　　　s = "safa"

int:bit_lenth()
    str:
        captilze() 首字母大写,其余小写.
        upper()   全大写.
        lower()   全小写.
        find()    通过元素找索引,没有返回-1,有切片.
        index()   通过元素找索引,没有回报错.有切片
        swapcase()  大小写反转.
        strip() 去除前后端的空格,\n,\t,
        strip('abc') 去除前后端的a ,b,c三个元素,
        ltrip ,rtrip
        title 非字母隔开的部分,首字母大写
        split  str---> list  默认以空格(可以设定分隔符),
        startswith  判断s以什么开头,返回bool值,可以切片
        endswith 判断以什么结尾,返回bool值,可以切片
        replace(old,new) 默认不写次数,全体换
        center 以其为中心,默认填充物 空格.
        count 计算元素出现的次数.
        len() 测量字符串的长度.
        join   '' '*' '_'....   .join(interable)
        isalpha()  全都是字母组成
        isdigit()  全都是数字组成
        isalnum()  全都是字母或者数字
        '%s' %(name)
        name1 = 'taibai '
        '%(name)s' %{name:name1}
        format
        '{}{}{}'.format(name,age,hobby)
        '{0}{1}{2}{1}'.format(name,age,bobby)
        '{name},{age}'.format(age=12,name='太白')

<br><br><br># name = 'aleX leNb'
# 1 移除name两边的空格
# print(name.strip())
# 2 移除name左边的al并输出
# print(name[2:])  # 切边方法
# 3 移除name后面的Nb并输出
# print(name[0:7])
# 4 移除name变量开头的a和结尾的b并输出
# print(name[1:8])
# 5 判断变量name是否以al开头，并输出  开头查找-startswith（）
# print(name.startswith('al'))
# 6 判断变量name是否以Nb结尾，并输出  结尾查找-endswith()
# print(name.endswith('Nb'))
# 7 将name变量中所有的l替换为 p  replace方法
# print(name.replace('l','p'))
# 8 将name变量中第一个l 替换为 p  参数为1 替换一次，不写默认替换全部
# print(name.replace('l', 'p', 1))
# 9 将name变量中对应的值根据'l'分割  分割方法-split()
# print(name.split('l'))
# 10 将name变量中对应的值根据第一个'l'分割  参数为1，分割一次。
# print(name.split('l', 1))
# 11 将name变量中的值变为大写输出  转大写方法- upper()
# print(name.upper())
# 12 将name变量中的值变为小写输出 转大写方法- lower()
# print(name.lower())
# 13 将name变量中a和l变为大写。# 解释：非字母隔开的字符串，首字母大写，其余字母小写
# print(name.title())
# 14 将name变量中a变为大写  # 解释：首字母大写， 其余字母小写
# print(name.capitalize())
# 15 判断name变量中对应的值'l '出现几次  查找元素出现的次数方法-count()
# print(name.count('l'))
# 16 判断name变量中前四位中'l '出现几次. 解释：先把name的前四位找出来，然后用count计算l的出现次数
# a = name[0:5]
# print(a.count('l'))
# 17 找到name变量中 N  的索引，如果找不到则报错  index方法，找不到会报错。find方法，找不到返回-1
# print(name.index('N'))
# print(name.find('n'))
# 18 找到name变量中  X le 对应的索引
# print(name.find('X le'))
# 19 请输入name变量值对应的的第2个字符
# print(name[2:3])
# 20 请输入name变量值对应的的第3个字符
# print(name[3:4])
# 21 请输入name变量值对应的后2个字符
# print(name[-1:-3:-1])
# 请输入name变量中 e 所在索引位置
# print(name.find('e'))
 
 
# 二
# 对s变量进行切片变成123
# s = '123a4b5c'
# print(s.strip('a4b5c'))
# 对s变量进行切边变成a4b
# print(s.strip('123,5c'))
# 对s变量进行切边变成1345
# print(s[0:7:2])
# print(s[: : 2])
# 对s变量进行切片变成2ab
# print(s[1:6:2])
 
# 使用while for 循环 打印字符串s='fsfaf'中的每个元素
# for循环
# s='fsfaf'
# for i in s:
#     print(i)
 
# while循环
# flag = True
# count = 0
# while flag:
#     print(s[count])
#     count += 1
#     if count == len(s):
#         flag = False
 
# while循环优化
# count = 0
# while count < len(s):
#     print(s[count])
#     count += 1

　　列表 list

　　元组 tuple

　　字典 dict

　　布尔值 bool

posted @ 2018-09-23 20:33 Bo.Tall 阅读(1023) 评论(0) 收藏举报

刷新页面返回顶部

Tallbo

a

Python运算符，基本数据类型

公告