变量、运算符与数据类型

一、 注释

1. 在 Python 中，# 表示注释，作用于整行。

【例子】单行注释

# 这是一个注释
print("Hello world!")
# Hello world!

2. ''' ''' 或者 """ """ 表示区间注释，在三引号之间的所有内容被注释

【例子】多行注释

'''
这是多行注释，用三个单引号
这是多行注释，用三个单引号
这是多行注释，用三个单引号
'''
print("Hello world!")
# Hello world!

"""
这是多行注释，用三个单引号
这是多行注释，用三个单引号
这是多行注释，用三个单引号
"""
print('Hello world!')
# Hello world!

【测试题1】使用(print)打印出 hello+你的姓名
如：print("hello 老表")

二、 运算符

1. 算术运算符

【例子】

print(1 + 1)    # 2
print(2-1)      # 1
print(3* 4)     # 12
print(3 /4)     # 0.75
print(3 // 4)   # 0
print(3 % 4)    # 3
print(2 ** 3)   # 8

2. 比较运算符

【例子】

print(2 > 1)    # True
print(2 >= 4)   # False
print(1 < 2)    # True
print(5 <= 2)   # False
print(3 == 4)   # False
print(3 != 5)   # True

3. 逻辑运算符

【例子】

print((3 > 2) and (3 < 5))  # True
print((1 > 3) or (9 < 2))   # False
print(not (2 > 1))          # False

4. 位运算符

【例子】有关二进制的运算。

print(bin(4))   # 0b100
print(bin(5))   # 0b101
print(bin(~4),~4) # -0b101 -5
print(bin(4 & 5),4 & 5) # 0b100 4
print(bin(4 | 5),4 | 5) # 0b101 5
print(bin(4 ^ 5),4 ^ 5) # 0b1 1
print(bin(4 << 2),4 << 2)   # 0b10000 16
print(bin(4 >> 2),4 >> 2)   # 0b1 1
print(bin(7))   # 0b111
print(bin(7 << 2),7 << 2)   # 0b11100 28
print(bin(7 >> 2),7 >> 2)   # 0b1 1

>>> print(bin(4))
0b100
>>> print(bin(5))
0b101
>>> print(bin(~4),~4)
-0b101 -5
>>> print(bin(4 & 5),4 & 5)
0b100 4
>>> print(bin(4))
0b100
>>> print(bin(5))
0b101
>>> print(bin(~4),~4)
-0b101 -5
>>> print(bin(4 & 5),4 & 5)
0b100 4
>>> print(bin(4 | 5),4 | 5)
0b101 5
>>> print(bin(4 ^ 5),4 ^ 5)
0b1 1
>>> print(bin(4 << 2),4 << 2)
0b10000 16
>>> print(bin(4 >> 2),4 >> 2)
0b1 1
>>> print(bin(7))
0b111
>>> print(bin(7 << 2),7 << 2)
0b11100 28
>>> print(bin(7 >> 2),7 >> 2)
0b1 1
>>> 

5. 三元运算符

三元运算是指一个运算符同时接受三个操作数，其语法格式为：条件表达式 ? 表达式1 : 表达式2。其中，“条件表达式”会先被计算，如果其结果为真，则返回“表达式1”的值；否则返回“表达式2”的值。
三元运算符之所以称为“三元”，是因为它需要同时接受三个操作数。与此对比，一元运算符只需要一个操作数，例如取反运算符“！”；二元运算符需要两个操作数，例如加减乘除等基本算术运算符。
【例子】

x, y = 4, 5
if x < y:
    small = x
else:
    small = y

print(small) # 4

>>> x, y = 4, 5
>>> if x < y:
...     small = x
... else:
...     small = y
... 
>>> print(small)
4
>>>

有了这个三元操作符的条件表达式，你可以使用一条语句来完成以上的条件判断和赋值操作。
【例子】

x, y = 4, 5
small = x if x < y else y
print(small)    # 4

>>> x, y = 4, 5
>>> small = x if x < y else y
>>> print(small)
4
>>>

6. 其他运算符

【例子】 in ; not in

letters = ['A', 'B', 'C']
if 'A' in letters:
    print('A' + ' exists')

# A exists
if 'h' not in ltters:
    print('h' + 'not exists')


# h not exists

>>> letters = ['A', 'B', 'C']
>>> if 'A' in letters:
...     print('A' + ' exists')
... 
A exists
>>> if 'D' not in letters:
...     print('D', 'not exists')
... 
D not exists
>>> 

【例子】比较的两个变量均指向不可变类型。

a='hello'
b='hello'
print(a is b, a == b)   # True True
print(a is not b, a !=b)    #False False

>>> a = "hello"
>>> b = "hello"
>>> print(a is b, a == b)
True True
>>> print(a is not b, a != b)
False False
>>> 

【例子】比较的两个变量均指向可变类型。

a = ["hello"]
b = ["hello"]
print(a is b, a == b)   # False True
print(a is not b, a != b)   # True False

>>> a = ["hello"]
>>> b = ["hello"]
>>> print(a is b, a == b)
False True
>>> print(a is not b, a != b)
True False
>>> 

注意：

• is, is not 对比的是两个变量的内存地址
• ==, != 对比的是两个变量的值
• 比较的两个变量，指向的都是地址不可变的类型（str等），那么is，is not 和 ==，！= 是完全等价的。
• 对比的两个变量，指向的是地址可变的类型（list，dict，tuple等），则两者是有区别的。

7. 运算符的优先级

同级别时按先后顺序。

【例子】

print(-3 ** 2)  # -9
print(3 ** -2)   # 0.1111111111111111(16个1)
print(1 << 3 + 2 & 7)   # 0
print(-3 * 2 + 5 / -2 - 4) # 12.5
print(3 < 4 and 4 < 5)  # True
print(3 < 4 or 4 < 5)   # True
print(not 3 < 4 or 4 < 5)  # True

>>> print(-3 ** 2)
-9
>>> print(3 ** -2)
0.1111111111111111
>>> print(1 << 3 + 2 & 7)
0

>>> print(3 + 2)
5
>>> print(1 << 5)
32
>>> print(32 & 7)
0

>>> print(-3 * 2 + 5 / -2 - 4)
-12.5
>>> print(-3 * 2)
-6
>>> print(5 / -2)
-2.5
>>> print( -6 + -2.5 - 4)
-12.5

>>> print(3 < 4 and 4 < 5)
True
>>> print(3 < 4)
True
>>> print(4 < 5)
True
>>> print(True and True)
True

>>> print(3 < 4 or 4 < 5)
True
>>> print(3 < 4)
True
>>> print(4 < 5)
True
>>> print(True or True)
True

>>> print(not 3 < 4 or 4 < 5)
True
>>> print(3 < 4)
True
>>> print(4 < 5)
True
>>> print(not True)
False
>>> print(False or True)
True

【我是测试题2】 下面一段代码运行结果是是那么？

# 运行一下结果就出来了
a = ["hello"]
b = ["hello"]
print(a is b, a == b)

三、 变量和赋值

• 在使用变量之前，需要对其先赋值。
• 变量名可以包括字母、数字、下划线、但变量名不能以数字开头。
• Python 变量名是大小写敏感的，foo != Foo

【例子】

teacher = "老马的程序人生"
print(teacher)  # 老马的程序人生

>>> teacher = "老马的程序人生"
>>> print(teacher)
老马的程序人生
>>> 

【例子】

first = 1
second = 2
third = first + second
print(third)    # 3

>>> first = 1
>>> second = 2
>>> third = first + second
>>> print(third)
3
>>> 

【例子】

myTeacher = "老马的程序人生"
yourTeacher = "小马的程序人生"
ourTeacher = myTeacher + "," + yourTeacher
print(ourTeacher)   # 老马的程序人生,小马的程序人生

>>> myTeacher = "老马的程序人生"
>>> yourTeacher = "小马的程序人生"
>>> ourTeacher = myTeacher + "," + yourTeacher
>>> print(ourTeacher)
老马的程序人生,小马的程序人生
>>> 

【我是测试题3】运行下面一段代码看看结果是什么？

# 运行一下就好啦
set_1 = {"欢迎","学习","Python"}
print(set_1.pop())

扩展

pop()是Python中内置的方法，用于从列表、集合或字典等可变容器中弹出指定位置（或随机位置）的一个元素，并将该元素从容器中删除。pop()是英文单词"pop"（意为“弹出”、“爆裂”等）的缩写。
在Python中，pop()方法有许多变种，包括：

• pop(i)：移除列表中第i个元素并返回它。如果不提供参数，则默认弹出最后一个元素。
• popitem()：随机弹出并返回一个键值对，通常用于弹出字典中的任意项。
• 在集合中，pop()方法等价于popany(),用于弹出任意一个元素并返回。
• 在堆（heap）中，heappop()方法用于从堆中删除并返回最小元素。
  总之，pop()方法可以帮助开发者删除序列、集合或映射的指定元素，从而使容器的大小得到更新。

四、 数据类型与转换

1. 整型

【例子】通过print()可以a的值，以及类(class)是int。

a = 1024
print(a, type(a))   # 1024 <class 'int'>

>>> a = 1024
>>> print(a, type(a))
1024 <class 'int'>
>>> b = "1024"
>>> print(b, type(b))
1024 <class 'str'>
>>> 

Python 里面万物皆对象(object)，整型也不例外，只要是对象，就有相应的属性 （attributes) 和方法(methods)。

【例子】

>>> b = dir(int)
>>> print(b)
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__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']
>>>

对它们有个大概印象就可以了，具体怎么用，需要哪些参数（argument），还需要文档，看个 bit_length()例子。
【例子】找到一个正数的二进制表示，再返回其长度。

a = 1024
print(bin(a))   # 0b10000000000
print(a.bit_length())   # 11

>>> a = 1024
>>> print(bin(a))
0b10000000000
>>> print(a.bit_length())
11
>>> 

dir() 是 Python 内置函数之一，用于返回指定对象（object）的所有属性和方法列表。如果不指定参数，则返回当前作用域内的所有名称。

2. 浮点型

【例子】

print(1, type(1))   # 1 <class 'int'>

print(1., type(1.)) # 1. <class 'float'

a = 0.00000023
b = 2.3e-7
print(a)    # 2.3e-7
print(b)    # 2.3e-7

>>> print(1, type(1))
1 <class 'int'>
>>> print(1., type(1.))
1.0 <class 'float'>
>>> 
>>> a = 0.00000023
>>> b = 23e-8
>>> print(a)
2.3e-07
>>> print(b)
2.3e-07
>>> 

decimal 是 Python 内置的一个模块，用于执行精确的十进制浮点数运算。与内置的 float 类型相比，decimal 提供了更高的精度和更可控的舍入方式，能够避免由于浮点数精度误差导致的计算错误。

有时候我们想保留浮点型的小数点后n位。可以用decimal包里的Decimal对象getcontext()方法来实现。

import decimal
form decimal import Decimal

Python 里面有很多用途广泛的包(package)，用什么你就引进(import)什么。包也是对象，也可以用上面提到的dir(decimal)来看其属性和方法。

>>> import decimal
>>> from decimal import Decimal
>>> dir(decimal)
['BasicContext', 'Clamped', 'Context', 'ConversionSyntax', 'Decimal', 'DecimalException', 'DecimalTuple', 'DefaultContext', 'DivisionByZero', 'DivisionImpossible', 'DivisionUndefined', 'ExtendedContext', 'FloatOperation', 'HAVE_CONTEXTVAR', 'HAVE_THREADS', 'Inexact', 'InvalidContext', 'InvalidOperation', 'MAX_EMAX', 'MAX_PREC', 'MIN_EMIN', 'MIN_ETINY', 'Overflow', 'ROUND_05UP', 'ROUND_CEILING', 'ROUND_DOWN', 'ROUND_FLOOR', 'ROUND_HALF_DOWN', 'ROUND_HALF_EVEN', 'ROUND_HALF_UP', 'ROUND_UP', 'Rounded', 'Subnormal', 'Underflow', '__builtins__', '__cached__', '__doc__', '__file__', '__libmpdec_version__', '__loader__', '__name__', '__package__', '__spec__', '__version__', 'getcontext', 'localcontext', 'setcontext']
>>> dir(Decimal)
['__abs__', '__add__', '__bool__', '__ceil__', '__class__', '__complex__', '__copy__', '__deepcopy__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__int__', '__le__', '__lt__', '__mod__', '__module__', '__mul__', '__ne__', '__neg__', '__new__', '__pos__', '__pow__', '__radd__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rmod__', '__rmul__', '__round__', '__rpow__', '__rsub__', '__rtruediv__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', 'adjusted', 'as_integer_ratio', 'as_tuple', 'canonical', 'compare', 'compare_signal', 'compare_total', 'compare_total_mag', 'conjugate', 'copy_abs', 'copy_negate', 'copy_sign', 'exp', 'fma', 'from_float', 'imag', 'is_canonical', 'is_finite', 'is_infinite', 'is_nan', 'is_normal', 'is_qnan', 'is_signed', 'is_snan', 'is_subnormal', 'is_zero', 'ln', 'log10', 'logb', 'logical_and', 'logical_invert', 'logical_or', 'logical_xor', 'max', 'max_mag', 'min', 'min_mag', 'next_minus', 'next_plus', 'next_toward', 'normalize', 'number_class', 'quantize', 'radix', 'real', 'remainder_near', 'rotate', 'same_quantum', 'scaleb', 'shift', 'sqrt', 'to_eng_string', 'to_integral', 'to_integral_exact', 'to_integral_value']
>>> 

【例子】 getcontext()显示了Decimal对象的默认精度值是 28 位(prec=28)。

aa = decimal.getcontext()
print(aa)

# Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
# capitals=1, clamp=0, flags=[], 
# traps=[InvalidOperation, DivisionByZero, Overflow])

>>> aa = decimal.getcontext()
>>> print(aa)
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
>>> 

>>> b = Decimal(1) / Decimal(3)
>>> print(b)
0.3333333333333333333333333333
>>> print(type(b))
<class 'decimal.Decimal'>
>>> 

【例子】使 1/3 保留 4 位，用 getcontext().prec 来调整精度。

decimal.getcontext().prec = 4
c = Decimal(1) / Decimal(3)
print(c)    # 0.3333

>>> decimal.getcontext().prec = 4
>>> c = Decimal(1) / Decimal(3)
>>> print(c,type(c))
0.3333 <class 'decimal.Decimal'>
>>> 

3. 布尔型

布尔(boolean)型变量只能取两个值，True和Float。当把布尔型变量用再数字运算中，用1和0代表True和Float。

【例子】

print(True + True)  # 2
print(True + False) # 1
print(True * False)    # 0

>>> print(True + True)
2
>>> print(True + False)
1
>>> print(True * False)
0
>>>

除了直接给变量赋值True和False，还可以用bool(X)来创建变量，其中X可以是

• 基本类型：整数、浮点型、布尔型
• 容器类型：字符串、元组、列表、字典和集合

【例子】 bool作用在基本类型变量：X只要是整型0、浮点型0.0，bool(X)就是False，其余就是True。

print(type(0), bool(0), bool(1))
# <class 'int'> False True

print(type(10.24), bool(0.00), bool(10.24))
# <class 'float'> False True

print(type(True), bool(False), bool(True))
# <class 'bool'> False True

>>> print(type(0),bool(0),bool(1))
<class 'int'> False True
>>> print(type(10.24), bool(0.00), bool(10.24))
<class 'float'> False True
>>> print(type(True), bool(False), bool(True))
<class 'bool'> False True
>>> 

【例子】 bool作用在容器类型变量：X 只要是空的变量，bool(X) 就是 False，其余就是True。

print(type(""), bool(""), bool("Python"))
# <class 'str'> False True

print(type(()), bool(()), bool((1, 2)))
# <class 'tuple'> False True

print(type([]), bool([]), bool([1, 2]))
# <class 'list'> False True

print(type({}), bool({}), bool({'first': 1, 'second': 2}))
# <class 'dict'> False True

print(type(set()), bool(set()), bool({1, 2}))
# <class 'set'> False True

>>> print(type(''), bool(''), bool('Python'))
<class 'str'> False True
>>> print(type(()), bool(()), bool((1,)))
<class 'tuple'> False True
>>> print(type([]), bool([]), bool([1, 2]))
<class 'list'> False True
>>> print(type({}), bool({}), bool({'a': 1, 'b': 2}))
<class 'dict'> False True
>>> print(type(set()), bool(set()), bool({1, 2}))
<class 'set'> False True
>>> 

确定bool(X)的值是True还是False，就看X是不是空，空的话就是False，不空的话就是True。

• 对于数值变量，0、0.0 都可认为时空的。
• 对于容器变量，里面没有元素就是空的。

4. 获取类型信息

• 获取类型信息 type(object)

【例子】

print(isinstance(1, int))   # True
print(isinstance(5.2, float))   # True
print(isinstance(True, bool))   # True
print(isinstance('5.2', str))   # True

>>> print(isinstance(6, int))
True
>>> print(isinstance(6.6, float))
True
>>> print(isinstance(True, bool))
True
>>> print(isinstance('5.2', str))
True
>>> 

注：

• type() 不会认为子类是一种父类类型，不考虑继承关系。
• isinstance() 会认为子类是一种父类类型，考虑继承关系。

5. 类型转换

• 转换为整型 int(x, base=10)
• 转为字符串 str(object='')
• 转为浮点型 float(x)

【例子】

print(int('1024'))   # 1024
print(int(6.6))   # 6
print(float('6.6'))   # 6.6
print(float(6)) # 6.0
print(str(10 + 10)) # 20
print(str(3.2 + 3.4))   # 6.6

>>> print(int('1024'))
1024
>>> print(int(6.6))
6
>>> print(float('6.6'))
6.6
>>> print(float(6))
6.0
>>> print(str(10 + 10))
20
>>> print(str(3.2 + 3.4))
6.6
>>> 

五、 print() 函数

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

• 将 对象 以 字符串表示的方式 格式化 输出到流文件对象file里。其中所有非关键字参数都按 str()方式进行转换为字符串输出；(objects是可变参数，表示要打印的内容。)
• 关键字参数sep是实现分割符，比如多个参数输出时想要输出中间的分隔符；
• 关键字参数end是输出结束时的字符，默认是换行符\n；
• 关键字参数file是定义流输出文件，可以是标准的系统输出sys.stdout, 也可以重定义为别的文件；(表示输出目标文件，如果未指定，则默认为sys.stdout，即控制台。)
• 关键字参数flush是立即把内容输出到流文件，不作缓存。(表示是否立即刷新输出缓冲区，默认为False。)

在Python的print()函数中，flush参数只有两种取值：True和False。当flush=True时，表示在打印完成后立即刷新输出缓冲区，这样可以保证立即将输出内容显示到屏幕上，而无需等待缓冲区满或程序结束。
例如，假设你有一个长时间运行的程序，在程序运行期间你想实时查看程序的运行状态，可以使用print()函数不断地输出当前状态信息，这时你就可以设置flush=True，以便将输出数据及时显示出来。但是，如果你的程序频繁调用print()函数，建议你谨慎使用flush=True，否则可能会降低程序性能。

【例子】没有参数时，每次输出后都会换行。

shoplist = ['apple', 'mango', 'carrot', 'banana']
print("This is printed without 'end' and 'sep'.")
# This is printed without 'end' and 'sep'.
for item in shoplist:
    print(item)

# apple
# manago
# carrot
# banana

>>> shoplist = ['apple', 'mango', 'carrot', 'banana']
>>> print("This is printed without 'end' and 'sep'.")
This is printed without 'end' and 'sep'.
>>> for item in shoplist:
...     print(item)
... 
apple
mango
carrot
banana
>>> 

【例子】 每次输出结束都用end 设置的参数 & 结尾，并没有默认换行。

shoplist = ['apple', 'mango', 'carrot', 'banana']
print("This is printed with 'end'='&'.")
# This is printed with 'end'='&'.
for item in shoplist:
    print(item, end='&')

# apple&mango&carrot&banana&>>>
print('huanhang')
# huanhang

>>> shoplist = ['apple', 'mango', 'carrot', 'banana']
>>> print("This is printed with 'end'='&'.")
This is printed with 'end'='&'.
>>> for item in shoplist:
...     print(item, end='&')
... 
apple&mango&carrot&banana&>>> print('huanhang')
huanhang
>>> 

【例子】item值与another string两个值之间用seq设置的参数&分割。由于end参数没有设置，因此默认是输出解释后换行，即end参数的默认值为\n。

shoplist = ['apple', 'mango', 'carrot', 'banana']
print("This is printed with 'sep'='&'.")
# This is printed with 'sep'='&'.
for item in shoplist:
    print(item, 'another string', sep='&')
# apple&another string
# mango&another string
# carrot&another string
# banana&another string

>>> shoplist = ['apple', 'mango', 'carrot', 'banana']
>>> print("This is printed with 'sep'='&'.")
This is printed with 'sep'='&'.
>>> for item in shoplist:
...     print(item, 'another string', sep='&')
... 
apple&another string
mango&another string
carrot&another string
banana&another string
>>> 

知识点补充：

1. 计算机系统中，数值，一律采用补码表示和存储。补码，其实就是一个代替负数的正数，使用了补码，计算机中就没有了负数。

2. 8 位二进制数能表示的十进制数范围为-128到+127。
3. 如果数小于-128或大于127，则会溢出，溢出只能使用两个字节，16位二进制表示。
4. 0 的补码位 00 00 00 00，-128 的补码为 10 00 00 00。
5. 计算机中有符号数用补码表示。
6. 原码首位为标志位，1表示负数，0表示正数。
7. 反码 = 原码的标志位不变，其它取反。
8. 补码 = 反码 + 1。
9. 正整数的原码、反码、补码相同。

在计算机中，补码是一种编码方式，用于表示有符号整数。它通过将减法运算转化为加法运算，简化了计算电路。正整数的补码与原码相同，而负整数的补码等于其对应正整数的补码按位取反后再加1。使用补码可以将有符号数的加减法、移位和逻辑运算等操作都统一到同一套规则下处理，方便计算和处理。计算机计算完成后，通常将结果以补码的形式存储在寄存器或内存中。但是，在将结果显示给用户时，通常需要将其从补码转换为十进制数或其他进制数，以便符合人类的习惯和需求。

如有错误欢迎指正，谢谢！

参考：
https://tianchi.aliyun.com/notebook/169961