目录
简介:
Python是一种跨平台的计算机程序设计语言。 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。最初被设计用于编写自动化脚本(shell),随着版本的不断更新和语言新功能的添加,越多被用于独立的、大型项目的开发。
变量、运算符与数据类型
1、注释
单行注释#
多行注释''' '''或""" """
# 这是一个单行注释
'''
这是多行注释
多行注释
'''
2. 运算符
算术运算符
操作符 名称 示例 结果 + 加 1+1 2 - 减 2-1 1 * 乘 3*4 12 / 除 3/4 0.75 // 整除(地板除) 3//4 0 % 取余 3%4 3 ** 幂 2**3 8
比较运算符
操作符 名称 示例 结果 > 大于 2>1 True >= 大于等于 2>=4 False < 小于 1<2 True <= 小于等于 5<=2 False == 等于 3==4 False != 不等于 3!=4 True
逻辑运算符
操作符 名称 示例 结果 助记 and 与 (3 > 2) and (3 < 5) True 都真才真 or 或 (1 > 3) or (9 < 2) False 有真则真 not 非 not (2 > 1) False
ps:计算and时,若第一个条件为假,则后面无需运算,结果必为假。
计算or时,若第一个条件为真,则后面无需运算,结果必为真。
位运算符
操作符 名称 示例 结果 ~ 按位取反 ~4 -5 & 按位与 4&5 4 | 按位或 4|5 5 ^ 按位异或 4^5 1 << 左移 4<<2 16 >> 右移 4>>2 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 | 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
三元运算符
x, y = 4, 5
small = x if x < y else y
print(small) # 4
small = x if x<y else y
的含义是:
- 如果
x<y
成立,就把 x 作为整个表达式的值,并赋给变量small
; - 如果
x<y
不成立,就把 y 作为整个表达式的值,并赋给变量small
。
其他运算符
操作符 名称 示例 结果 in 存在 'A' in ['A', 'B', 'C'] True not in 不存在 'h' not in ['A','B','C'] True is 是 "hello" is "hello" True not is 不是 "hello" is not "hello" False
# a,b两个变量均指向不可变类型
a = "hello"
b = "hello"
print(a is b, a == b) # True True
print(a is not b, a != b) # False False
# x,y两个变量均指向不可变类型
x = ["hello"]
y = ["hello"]
print(x is y, x == y) # False True
print(x is not y, x != y) # True False
ps:
- is, is not 对比的是两个变量的内存地址
- ==, != 对比的是两个变量的值
- 比较的两个变量,指向的都是地址不可变的类型(str等),那么is,is not 和 ==,!= 是完全等价的。
- 对比的两个变量,指向的是地址可变的类型(list,dict,tuple等),则两者是有区别的。
运算符的优先级
- 一元运算符优于二元运算符。例如
3 ** -2
等价于3 ** (-2)
。 - 先算术运算,后移位运算,最后位运算。例如
1 << 3 + 2 & 7
等价于(1 << (3 + 2)) & 7
。 - 逻辑运算最后结合。例如
3 < 4 and 4 < 5
等价于(3 < 4) and (4 < 5)
。
print(-3 ** 2) # -9
print(3 ** -2) # 0.1111111111111111 3的负二次方
print(1 << 3 + 2 & 7) # 0 先3+2,然后1左移5位得100000,与000111按位与得0
print(-3 * 2 + 5 / -2 - 4) # -12.5 -6-2.5-4=-12.5
print(3 < 4 and 4 < 5) # True True and True
3、变量和赋值
- 在使用变量之前,需要对其先赋值。
- 变量名可以包括字母、数字、下划线、但变量名不能以数字开头。
- Python 变量名是大小写敏感的,foo != Foo。
4、数据类型与转换
类型 | 名称 | 示例 |
int | 整型 <class 'int'> | -876, 10 |
float | 浮点型<class 'float'> | 3.149, 11.11 |
bool | 布尔型<class 'bool'> | True, False |
整型
type() 函数如果你只有第一个参数则返回对象的类型,三个参数返回新的类型对象。
dir() 函数不带参数时,返回当前范围内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。
bin()函数找到一个整数的二进制表示,变量.bit_length()返回其二进制表示的长度。
a = 1031
print(a, type(a))
# 1031 <class 'int'>
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']
a = 1031
print(bin(a)) # 0b10000000111
print(a.bit_length()) # 11
浮点型
有时候我们想保留浮点型的小数点后 n
位。可以用 decimal
包里的 Decimal
对象和 getcontext()
方法来实现。
import decimal
from decimal import Decimal
print(1, type(1))
# 1 <class 'int'>
print(1., type(1.))
# 1.0 <class 'float'>
a = 0.00000023
b = 2.3e-7
print(a) # 2.3e-07
print(b) # 2.3e-07
b = Decimal(1) / Decimal(3)
print(b) # 0.3333333333333333333333333333
decimal.getcontext().prec = 4
c = Decimal(1) / Decimal(3)
print(c) # 0.3333
布尔型
布尔 (boolean) 型变量只能取两个值,True
和 False
。当把布尔型变量用在数字运算中,用 1
和 0
代表 True
和 False
。
除了直接给变量赋值 True
和 False
,还可以用 bool(X)
来创建变量,其中 X
可以是
- 基本类型:整型、浮点型、布尔型
- 容器类型:字符串、元组、列表、字典和集合
bool
作用在基本类型变量:X
只要不是整型 0
、浮点型 0.0
,bool(X)
就是 True
,其余就是 False
。
bool
作用在容器类型变量:X
只要不是空的变量,bool(X)
就是 True
,其余就是 False
。
print(type(0), bool(0), bool(1))
# <class 'int'> False True
print(type(10.31), bool(0.00), bool(10.31))
# <class 'float'> False True
print(type(True), bool(False), bool(True))
# <class 'bool'> False True
print(type(''), bool(''), bool('python'))
# <class 'str'> False True
print(type(()), bool(()), bool((10,)))
# <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
获取类型信息
获取类型信息 type(object)
print(isinstance(1, int)) # True
print(isinstance(5.2, float)) # True
print(isinstance(True, bool)) # True
print(isinstance('5.2', str)) # True
type()
不会认为子类是一种父类类型,不考虑继承关系。isinstance()
会认为子类是一种父类类型,考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()
。
类型转换
- 转换为整型
int(x, base=10)
- 转换为字符串
str(object='')
- 转换为浮点型
float(x)
5、print函数
没有参数时,每次输出后都会换行。
- 将对象以字符串表示的方式格式化输出到流文件对象file里。其中所有非关键字参数都按
str()
方式进行转换为字符串输出; - 关键字参数
sep
是实现分隔符,比如多个参数输出时想要输出中间的分隔字符; - 关键字参数
end
是输出结束时的字符,默认是换行符\n
; - 关键字参数
file
是定义流输出的文件,可以是标准的系统输出sys.stdout
,也可以重定义为别的文件; - 关键字参数
flush
是立即把内容输出到流文件,不作缓存。
shoplist = ['apple', 'mango', 'carrot', 'banana']
print("This is printed without 'end'and 'sep'.")
for item in shoplist:
print(item)
# This is printed without 'end'and 'sep'.
# apple
# mango
# carrot
# banana
6、位运算
原码、反码、补码
二进制有三种不同的表示形式:原码、反码和补码,计算机内部使用补码来表示。
原码:就是其二进制表示(注意,有一位符号位)。
00 00 00 11 -> 3
10 00 00 11 -> -3
反码:正数的反码就是原码,负数的反码是符号位不变,其余位取反(对应正数按位取反)。
00 00 00 11 -> 3
11 11 11 00 -> -3
补码:正数的补码就是原码,负数的补码是反码+1。
00 00 00 11 -> 3
11 11 11 01 -> -3
符号位:最高位为符号位,0表示正数,1表示负数。在位运算中符号位也参与运算。
按位运算
- 按位非操作 ~
~ 1 = 0
~ 0 = 1
~
把num
的补码中的 0 和 1 全部取反(0 变为 1,1 变为 0),有符号整数的符号位在 ~
运算中同样会取反。
00 00 01 01 -> 5
~
---
11 11 10 10 -> -6
11 11 10 11 -> -5
~
---
00 00 01 00 -> 4
- 按位与操作 &
1 & 1 = 1
1 & 0 = 0
0 & 1 = 0
0 & 0 = 0
只有两个对应位都为 1 时才为 1
00 00 01 01 -> 5
&
00 00 01 10 -> 6
---
00 00 01 00 -> 4
- 按位或操作 |
1 | 1 = 1
1 | 0 = 1
0 | 1 = 1
0 | 0 = 0
只要两个对应位中有一个 1 时就为 1
00 00 01 01 -> 5
|
00 00 01 10 -> 6
---
00 00 01 11 -> 7
- 按位异或操作 ^
1 ^ 1 = 0
1 ^ 0 = 1
0 ^ 1 = 1
0 ^ 0 = 0
只有两个对应位不同时才为 1,注意:0^0=0,1^1=0
00 00 01 01 -> 5
^
00 00 01 10 -> 6
---
00 00 00 11 -> 3
异或操作的性质:满足交换律和结合律
A: 00 00 11 00
B: 00 00 01 11
A^B: 00 00 10 11
B^A: 00 00 10 11
A^A: 00 00 00 00
A^0: 00 00 11 00
A^B^A: = A^A^B = B = 00 00 01 11
- 按位左移操作 <<
num << i
将num
的二进制表示向左移动i
位所得的值。
00 00 10 11 -> 11
11 << 3
---
01 01 10 00 -> 88
- 按位右移操作 >>
num >> i
将num
的二进制表示向右移动i
位所得的值。
00 00 10 11 -> 11
11 >> 2
---
00 00 00 10 -> 2
利用位运算实现整数集合
一个数的二进制表示可以看作是一个集合(0 表示不在集合中,1 表示在集合中)。
比如集合 {1, 3, 4, 8}
,可以表示成 01 00 01 10 10
而对应的位运算也就可以看作是对集合进行的操作。就是说这个数的对应二进制位中,第一位、第三位、第四位、第八位为1,其余为0。
元素与集合的操作:
a | (1<<i) -> 把 i 插入到集合中
a & ~(1<<i) -> 把 i 从集合中删除
a & (1<<i) -> 判断 i 是否属于该集合(零不属于,非零属于)
集合之间的操作:
a 补 -> ~a
a 交 b -> a & b
a 并 b -> a | b
a 差 b -> a & (~b)
注意:整数在内存中是以补码的形式存在的,输出自然也是按照补码输出。
C#语言输出负数
class Program
{
static void Main(string[] args)
{
string s1 = Convert.ToString(-3, 2);
Console.WriteLine(s1);
// 11111111111111111111111111111101
string s2 = Convert.ToString(-3, 16);
Console.WriteLine(s2);
// fffffffd
}
}
python的bin()输出
print(bin(3)) # 0b11
print(bin(-3)) # -0b11
print(bin(-3 & 0xffffffff))
# 0b11111111111111111111111111111101
print(bin(0xfffffffd))
# 0b11111111111111111111111111111101
print(0xfffffffd) # 4294967293
- Python中
bin
一个负数(十进制表示),输出的是它的原码的二进制表示加上个负号。 - Python中的整型是补码形式存储的。
- Python中整型是不限制长度的不会超范围溢出。
所以为了获得负数(十进制表示)的补码,需要手动将其和十六进制数0xffffffff
进行按位与操作,再交给bin()
进行输出,得到的才是负数的补码表示。