python基础语法
逆境前行，能帮你的只有自己
重点
1.计算机基础：
^ 按位异或运算符：当两对应的二进位相异时，结果为1 (a ^ b) 输出结果 49 ，二进制解释：0011 0001
~ 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x类似于 -x-1
2.原码、反码、补码
1.编程基础
1.1 计算机语言
人与计算机之间交互的语言
机器语言
一定位数组成二进制的0和1的序列，称为机器指令。机器指令的集合就是机器语言
与自然语言差异太大，难学、难懂、难写、难记、难查错
汇编语言
用一些助记符号替代机器指令，称为汇编语言。ADD A,B 指的是将寄存器A的数与寄存器B的数相加得到的数放到寄存器A中
汇编语言写好的程序需要汇编程序转换成机器指令
汇编语言只是稍微好记了些，可以认为就是机器指令对应的助记符。只是符号本身接近自然语言
1.2 语言分类
低级语言
面向机器的语言，分为机器语言和汇编语言
高级语言
接近自然语言和数学语言的计算机语言
高级语言首先要书写源程序，通过编译程序把源程序转换成机器指令的程序
1954年正式发布的Fortran语言是最早的高级语言，本意是公式翻译
人们只需要关心怎么书写源程序，针对不同机器的编译的事交给编译器关心处理
1.3 程序
程序是一个指令序列，算法+数据结构=程序
为了使计算机程序得以运行，计算机需要加载代码，同时也要加载数据。从计算机的底层来说，这是由高级语言(例如Java，C/C++，C#等)代码转译成机器语言而被CPU所理解，进行加载
1.4 写程序难点
理不清数据
搞不清处理方法
无法把数据设计转换成数据结构，无法把处理方法转换成算法
无法用设计范式来进行程序设计
世间程序皆有bug，但要会debug
2.python简介
2.1python解释器
当我们编写Python代码时，我们得到的是一个包含Python代码的以.py为扩展名的文本文件。要运行代码，就需要Python解释器去执行.py文件。
由于整个Python语言从规范到解释器都是开源的，所以理论上，只要水平够高，任何人都可以编写Python解释器来执行Python代码(当然难度很大)。事实上，确实存在多种Python解释器。
CPython
当我们从Python官方网站下载并安装好Python 2.7后，我们就直接获得了一个官方版本的解释器：CPython。这个解释器是用C语言开发的，所以叫CPython。在命令行下运行python就是启动CPython解释器。
CPython是使用最广的Python解释器。教程的所有代码也都在CPython下执行。
IPython
IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执行Python代码的功能和CPython是完全一样的。好比很多国产浏览器虽然外观不同，但内核其实都是调用了IE。
CPython用>>>作为提示符，而IPython用In [序号]:作为提示符。
PyPy
PyPy是另一个Python解释器，它的目标是执行速度。PyPy采用JIT技术，对Python代码进行动态编译(注意不是解释)，所以可以显著提高Python代码的执行速度。
绝大部分Python代码都可以在PyPy下运行，但是PyPy和CPython有一些是不同的，这就导致相同的Python代码在两种解释器下执行可能会有不同的结果。如果你的代码要放到PyPy下执行，就需要了解PyPy和CPython的不同点。
Jython
Jython是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。
IronPython
IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。
小结
Python的解释器很多，但使用最广泛的还是CPython。如果要和Java或.Net平台交互，最好的办法不是用Jython或IronPython，而是通过网络调用来交互，确保各程序之间的独立性。
3.python基础语法
注释
以#开头的语句是注释，注释是给人看的，可以是任意内容，解释器会忽略掉注释。其他每一行都是一个语句，当语句以冒号“:”结尾时，缩进的语句视为代码块。
ln[1]:asxprint('hello world') #这是注释
# 整行都是注释 print('hello world2')
hello world
数字
分为整数、浮点数
整数：Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。
计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等。
浮点数：浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的(除法难道也是精确的？是的！)，而浮点数运算则可能会有四舍五入的误差。
ln [1]:7e9
out[1]:7000000000.0
ln [1]:100
out[1]：100
ln [1]:0.99
out[1]：0.99
字符串
单双引号：字符串是以''或""括起来的任意文本，比如'abc'，"xyz"等等。请注意，''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。如果'本身也是一个字符，那就可以用""括起来，比如"I'm OK"包含的字符是I，'，m，空格，O，K这6个字符。
三引号：'''和"""单双三引号，可以跨行、可以在其中自由的使用单双引号，在字符串前面加上r或者R前缀，表示该字符串不做特殊的处理
ln [1]:print('hello world') hello world
ln [2]:print("hello python")hello python
ln [3]:print("'hello pythons'")'hello pythons'
ln [4]:print("""welcome to\ my\ blog""")welcome tomyblog
ln [5]:print(r"""welcome to\ my\ blog""")welcome to\my\blog
转义序列
\ \t \r \n ' "前缀r，把里面的所有字符当普通字符对待
缩进
约定使用4个空格缩进
续行
在行尾使用\，如果使用各种括号，认为括号内是一个整体，内部跨行不用\
标识符
1.一个名字，用来指代一个值
2.只能字母、下划线和数字
3.只能以字母或下划线开头
4.不能是python的关键字，例如def、class就不能作为标识
5. Python是大小写敏感的
约定：不允许使用中文
不允许使用歧义单词，例如class_在python中
不要随便使用下划线开头的标示符
python的语言类型
Python是动态语言、强类型语言
静态编译语言
实现声明变量类型，类型不能再改变；编译时检查
动态编译语言
不用事先声明类型，随时可以赋值为其他类型；编程时不知道是什么类型，很难推断
强类型语言
不同类型之间操作，必须先强制类型转换为同一类型。print('a'+1)
弱类型语言
不同类型间可以操作，自动隐式转换，JavaScript中console.log(1+'a')
![]()
python运算符
Python语言支持以下类型的运算符:
算术运算符
比较(关系)运算符
赋值运算符
逻辑运算符
位运算符
成员运算符
身份运算符
运算符优先级
python算术运算符
ln [1]:1+1.496 #加法2.496
ln [2]:3-1.111 #减法1.889
ln [3]:3*7 #乘法21
ln [4]:8/3 #除法2.6666666666666665
ln [5]:8//3 #整除2
ln [6]:2**5 #乘方算法32
in [7]:567%10 #取余数7
python比较运算符
以下假设变量a为10，变量b为20：
运算符
描述
实例
==
等于 - 比较对象是否相等
(a == b) 返回 False。
!=
不等于 - 比较两个对象是否不相等
(a != b) 返回 true.
<>
不等于 - 比较两个对象是否不相等
(a <> b) 返回 true。这个运算符类似 != 。
>
大于 - 返回x是否大于y
(a > b) 返回 False。
<
小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。
(a < b) 返回 true。
>=
大于等于 - 返回x是否大于等于y。
(a >= b) 返回 False。
<=
小于等于 - 返回x是否小于等于y。
(a <= b) 返回 true。
以下实例演示了Python所有比较运算符的操作：
ln [1]:a = 21 b = 21
if a == b :
print ("a 等于 b")
else:
print ("a 不等于 b")
a 等于 b
ln [2]:a = 21 b = 10
if a != b :
print ("a 不等于 b")
else:
print ("a 等于 b")
a 不等于 b
ln [3]:a = 21 b = 21 if a >= b : print ("a >= b") else: print ("a < b")a >= b
python比较运算符
按位运算符是把数字看作二进制来进行计算的
二进制口诀：8421
十进制
十六进制
二进制
Symbol
十进制
十六进制
二进制
Symbol
0
00
0000 0000
NUL
64
40
0100 0000
@
1
01
0000 0001
SOH
65
41
0100 0001
A
2
02
0000 0010
STX
66
42
0100 0010
B
3
03
0000 0011
ETX
67
43
0100 0011
C
4
04
0000 0100
EOT
68
44
0100 0100
D
5
05
0000 0101
ENQ
69
45
0100 0101
E
6
06
0000 0110
ACK
70
46
0100 0110
F
7
07
0000 0111
BEL
71
47
0100 0111
G
8
08
0000 1000
BS
72
48
0100 1000
H
9
09
0000 1001
TAB
73
49
0100 1001
I
10
0A
0000 1010
LF
74
4A
0100 1010
J
11
0B
0000 1011
VT
75
4B
0100 1011
K
12
0C
0000 1100
FF
76
4C
0100 1100
L
13
0D
0000 1101
CR
77
4D
0100 1101
M
14
0E
0000 1110
SO
78
4E
0100 1110
N
15
0F
0000 1111
Sl
79
4F
0100 1111
O
16
10
0001 0000
DLE
80
50
0101 0000
P
17
11
0001 0001
DC1
81
51
0101 0001
Q
18
12
0001 0010
DC2
82
52
0101 0010
R
19
13
0001 0011
DC3
83
53
0101 0011
S
20
14
0001 0100
DC4
84
54
0101 0100
T
21
15
0001 0101
NAK
85
55
0101 0101
U
22
16
0001 0110
SYN
86
56
0101 0110
V
23
17
0001 0111
ETB
87
57
0101 0111
W
24
18
0001 1000
CAN
88
58
0101 1000
X
25
19
0001 1001
EM
89
59
0101 1001
Y
26
1A
0001 1010
SUB
90
5A
0101 1010
Z
27
1B
0001 1011
ESC
91
5B
0101 1011
[
28
1C
0001 1100
FS
92
5C
0101 1100
/
29
1D
0001 1101
GS
93
5D
0101 1101
]
30
1E
0001 1110
RS
94
5E
0101 1110
^
31
1F
0001 1111
US
95
5F
0101 1111
_
32
20
0010 0000
(space)
96
60
0110 0000
`
33
21
0010 0001
!
97
61
0110 0001
a
34
22
0010 0010
"
98
62
0110 0010
b
35
23
0010 0011
#
99
63
0110 0011
c
36
24
0010 0100
$
100
64
0110 0100
d
37
25
0010 0101
%
101
65
0110 0101
e
38
26
0010 0110
&
102
66
0110 0110
f
39
27
0010 0111
`
103
67
0110 0111
g
40
28
0010 1000
(
104
68
0110 1000
h
41
29
0010 1001
)
105
69
0110 1001
i
42
2A
0010 1010
*
106
6A
0110 1010
j
43
2B
0010 1011
+
107
6B
0110 1011
k
44
2C
0010 1100
,
108
6C
0110 1100
l
45
2D
0010 1101
-
109
6D
0110 1101
m
46
2E
0010 1110
.
110
6E
0110 1110
n
47
2F
0010 1111
/
111
6F
0110 1111
o
48
30
0011 0000
0
112
70
0111 0000
p
49
31
0011 0001
1
113
71
0111 0001
q
50
32
0011 0010
2
114
72
0111 0010
r
51
33
0011 0011
3
115
73
0111 0011
s
52
34
0011 0100
4
116
74
0111 0100
t
53
35
0011 0101
5
117
75
0111 0101
u
54
36
0011 0110
6
118
76
0111 0110
v
55
37
0011 0111
7
119
77
0111 0111
w
56
38
0011 1000
8
120
78
0111 1000
x
57
39
0011 1001
9
121
79
0111 1001
y
58
3A
0011 1010
:
122
7A
0111 1010
z
59
3B
0011 1011
;
123
7B
0111 1011
{
60
3C
0011 1100
<
124
7C
0111 1100
61
3D
0011 1101
=
125
7D
0111 1101
}
62
3E
0011 1110
>
126
7E
0111 1110
~
63
3F
0011 1111
?
127
7F
0111 1111
运算符
描述
实例
&
按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
(a & b) 输出结果 12 ，二进制解释：0000 1100
按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。
(a| b) 输出结果 61 ，二进制解释：0011 1101
^
按位异或运算符：当两对应的二进位相异时，结果为1
(a ^ b) 输出结果 49 ，二进制解释：0011 0001
~
按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x类似于 -x-1
(~a ) 输出结果 -61 ，二进制解释：1100 0011， 在一个有符号二进制数的补码形式。
<<
左移动运算符：运算数的各二进位全部左移若干位，由"<
a << 2 输出结果 240 ，二进制解释：1111 0000
>>
右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数
a >> 2 输出结果 15 ，二进制解释：0000 1111
a = 21
a=60 #60=0011 1100
b=13 #13=0000 1101
c=a & b; #计算 & 运算符
print(c)
12
a=60 #60=0011 1100
b=13 #13=0000 1101
c=a | b; #计算 | 运算符
print(c)
61
a=60 #60=0011 1100
b=13 #13=0000 1101
c=a ^ b; #计算 ^ 运算符
异或运算符：当两对应的二进位相异时，结果为1
print(c)
49
按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x类似于 -x-1
~13 # 13=0000 1101
-14
4>>2 # 4= 0000 01001
python运算符优先级
运算符
描述
**
指数 (最高优先级)
~ + -
按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //
乘，除，取模和取整除
+ -
加法减法
>> <<
右移，左移运算符
&
位 'AND'
^
| 位运算符
<= < > >=
比较运算符
<> == !=
等于运算符
= %= /= //= -= += *= **=
赋值运算符
is is not
身份运算符
in not in
成员运算符
not and or
逻辑运算符
原码、反码与补码
![]()
计算机中数据是怎么放到内存中的？
原码、反码、补码；负数表示法(***)
计算机中正数的补码、反码、原码都是一样的；负数补码的补码就是原码；
机器码：
补码是留给计算机放在内存中自己玩的，你要用，计算机会先转换为原码，原码更贴近于人；
1000 0000 (-1) #负数最高位1
0000 1100 #12
1111 0011 #结果取反 补码 1 负数
1000 1101 #符号位不变(-1)，按照位置取反后加1 -13
表达式Expression
由数字、符号、括号、变量组成
分为算术表达式，逻辑表达式，赋值表达式
Python中，赋值即是定义(非常重要)
转播
