1.注释
井号开头为注释
2.数字
3.字符串
4.转移序列
5.缩进
6.续行
7标识符
8语言类型
- 8.1静态编译型语言
- 8.2动态编译语言
9.运算符
!/usr/bin/python3
修改变量 a 的值
- 9.6成员运算符
- 9.7身份运算符
10运算符优先级
11.False等价
12.表达式
13.内嵌函数
14.程序控制

1.注释

井号开头为注释

2.数字

整数int

Python3开始不在区分long、int、long被重命名为int,所以只有int类型了
进制表示
- 十进制10
- 十六进制0xa
- 八进制0o10
- 二进制0b10
bool类型,有两个值True、False

浮点数float

1.2、3.1415、-0.12、1.46e9等价于科学及算法1.46*10^9^
本质上使用了C语言的double类型

复数complex

1+2j或1+2J

3.字符串
使用’”单双引号引用的字符的序列
‘’’和”””单双三引号,可以跨行、可以在其中自由的使用单双引号
r前缀: 在字符串前面加上r或者R前缀,表示该字符串不做特殊的处理
f前缀: 3.6版本开始,新增f前缀,格式化字符串 :::info a=”zhangtong”
print(a) ::: :::info a=’zhangtong’
print(a) ::: :::info a=r”123\n456”
print(a) :::
```
#插值
a = 1
b = 100
'{}+{}'.format(a,b)
f'{a} {b}'
```
4.转移序列
\ \t \r \n ; “
前缀r,把里面所有的字符当成普通字符对待,则转移字符就不转移了

5.缩进
未使用C语言的花括号,而是采用缩进的方式表示层次关系
约定使用4个空格缩进

6.续行
在结尾使用\,注意\之后除了紧跟着换行之外不能有其他字符
如果使用各种括号内是一个整体,其内部跨行不用\

7标识符

7.1标识符
1.一个名字,用来指代一个值
2.只能是数组、下划线和数字
3.只能以字母或下划线开头
4.不能是python的关键字,例如def、class不能作为标识符
5.Python是大小写敏感的
标识符约定:
不允许使用中文,也不建议用拼音
不要使用歧义单词,例如class
在python中不要随便使用下划线开头的标识符

Pyton保留字不能设置为变量:查询方法 :::info import keyword
keyword.kwlist :::

7.2常量

一旦赋值就不能改变值的标识符
python中无法定义常量

7.3字面常量
一个单独的不可变量,例如12、”abc”、”2341356614.03e-9”

7.4变量
赋值后,可以改变的标识符

7.5标识符本质
每一个标识符对应一个具有数据结构的值,但是这个值不方便直接访问,程序员就可以通过其对应的标识符来访问数据,标识符就是一个指代.

8语言类型
Python是动态语言、强类型语言。

8.1静态编译型语言
实现声明变量类型,类型不能改变
编译时检查

8.2动态编译语言
不用事先声明类型,随时可以赋值为其他类型
编程时不知道是什么类型,很难推断
9.运算符
9.1算数运算符
| 运算符 | 描述 | 实例 | | —- | —- | —- | | + | 加 - 两个对象相加 | a + b 输出结果 31 | | - | 减 - 得到负数或是一个数减去另一个数 | a - b 输出结果 -11 | | | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a b 输出结果 210 | | / | 除 - x 除以 y | b / a 输出结果 2.1 | | % | 取模 - 返回除法的余数 | b % a 输出结果 1 | | | 幂 - 返回x的y次幂 | ab 为10的21次方 | | // | 取整除 - 向下取接近商的整数 | >>> 9//2 4 >>> -9//2 -5 |

+、-、、/、//向下取整整除、*幂
注:再Python2中/和//都是整除

#!/usr/bin/python3
a = 21
b = 10
c = 0
c = a + b
print ("1 - c 的值为：", c)
c = a - b
print ("2 - c 的值为：", c)
c = a * b
print ("3 - c 的值为：", c)
c = a / b
print ("4 - c 的值为：", c)
c = a % b
print ("5 - c 的值为：", c)
# 修改变量 a 、b 、c
a = 2
b = 3
c = a**b 
print ("6 - c 的值为：", c)
a = 10
b = 5
c = a//b 
print ("7 - c 的值为：", c)

9.2位运算符

运算符	描述	实例
&	按位与运算符：参与运算的两个值,如果两个相应位都为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，在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由”<<”右边的数指定移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把”>>”左边的运算数的各二进位全部右移若干位，”>>”右边的数指定移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

&位与、|位或、^异或、<<左移、>>右移
~按位取反,包括符号位

#!/usr/bin/python3
a = 60            # 60 = 0011 1100 
b = 13            # 13 = 0000 1101 
c = 0
c = a & b        # 12 = 0000 1100
print ("1 - c 的值为：", c)
c = a | b        # 61 = 0011 1101 
print ("2 - c 的值为：", c)
c = a ^ b        # 49 = 0011 0001
print ("3 - c 的值为：", c)
c = ~a           # -61 = 1100 0011
print ("4 - c 的值为：", c)
c = a << 2       # 240 = 1111 0000
print ("5 - c 的值为：", c)
c = a >> 2       # 15 = 0000 1111
print ("6 - c 的值为：", c)

9.3比较运算符

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(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。

==、!=、>、>=、<、<=
链式比较: 4>3>2
比较运算符,返回一个bool值

#!/usr/bin/python3
a = 21
b = 10
c = 0
if ( a == b ):
   print ("1 - a 等于 b")
else:
   print ("1 - a 不等于 b")
if ( a != b ):
   print ("2 - a 不等于 b")
else:
   print ("2 - a 等于 b")
if ( a < b ):
   print ("3 - a 小于 b")
else:
   print ("3 - a 大于等于 b")
if ( a > b ):
   print ("4 - a 大于 b")
else:
   print ("4 - a 小于等于 b")
# 修改变量 a 和 b 的值
a = 5
b = 20
if ( a <= b ):
   print ("5 - a 小于等于 b")
else:
   print ("5 - a 大于  b")
if ( b >= a ):
   print ("6 - b 大于等于 a")
else:
   print ("6 - b 小于 a")

9.4逻辑运算符

运算符	逻辑表达式	描述	实例
and	x and y	布尔”与” - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔”或” - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔”非” - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

与and、或or、非not
逻辑运算符也是短路运算符

and如果前面的表示大师等价为False,后面就没有必要计算了,这个逻辑表达式最终一定等价为False

1 and ‘2’ and 0
0 and ‘abc’ and 1

or如果前面的表达式等价为True后面没有必要计算了,这个逻辑表达式最终一定等价为True

1 or False or None

把最频繁使用的,最少计算就可以知道结果的条件放到前面,如果他能短路,将大大减少计算量 ```python
!/usr/bin/python3

a = 10 b = 20

if ( a and b ): print (“1 - 变量 a 和 b 都为 true”) else: print (“1 - 变量 a 和 b 有一个不为 true”)

if ( a or b ): print (“2 - 变量 a 和 b 都为 true，或其中一个变量为 true”) else: print (“2 - 变量 a 和 b 都不为 true”)

修改变量 a 的值

a = 0 if ( a and b ): print (“3 - 变量 a 和 b 都为 true”) else: print (“3 - 变量 a 和 b 有一个不为 true”)

if ( a or b ): print (“4 - 变量 a 和 b 都为 true，或其中一个变量为 true”) else: print (“4 - 变量 a 和 b 都不为 true”)

if not( a and b ): print (“5 - 变量 a 和 b 都为 false，或其中一个变量为 false”) else: print (“5 - 变量 a 和 b 都为 true”)

<a name="U9a1g"></a>
## 9.5赋值运算符
| 运算符 | 描述 | 实例 |
| --- | --- | --- |
| = | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
| += | 加法赋值运算符 | c += a 等效于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等效于 c = c - a |
| *= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
| /= | 除法赋值运算符 | c /= a 等效于 c = c / a |
| %= | 取模赋值运算符 | c %= a 等效于 c = c % a |
| **= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
| //= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
| := | 海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。 | 在这个示例中，赋值表达式可以避免调用 len() 两次:<br />if (n := len(a)) > 10:     print(f"List is too long ({n} elements, expected <= 10)") |
a = min(3,5)<br />+=、-=、*=、%=、//=<br />x=y=z=10
```python
#!/usr/bin/python3
a = 21
b = 10
c = 0
c = a + b
print ("1 - c 的值为：", c)
c += a
print ("2 - c 的值为：", c)
c *= a
print ("3 - c 的值为：", c)
c /= a 
print ("4 - c 的值为：", c)
c = 2
c %= a
print ("5 - c 的值为：", c)
c **= a
print ("6 - c 的值为：", c)
c //= a
print ("7 - c 的值为：", c)

9.6成员运算符

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

#!/usr/bin/python3
a = 10
b = 20
list = [1, 2, 3, 4, 5 ]
if ( a in list ):
   print ("1 - 变量 a 在给定的列表中 list 中")
else:
   print ("1 - 变量 a 不在给定的列表中 list 中")
if ( b not in list ):
   print ("2 - 变量 b 不在给定的列表中 list 中")
else:
   print ("2 - 变量 b 在给定的列表中 list 中")
# 修改变量 a 的值
a = 2
if ( a in list ):
   print ("3 - 变量 a 在给定的列表中 list 中")
else:
   print ("3 - 变量 a 不在给定的列表中 list 中")

9.7身份运算符

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ，类似 id(x) != id(y)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

id() 函数用于获取对象内存地址。

#!/usr/bin/python3
a = 20
b = 20
if ( a is b ):
   print ("1 - a 和 b 有相同的标识")
else:
   print ("1 - a 和 b 没有相同的标识")
if ( id(a) == id(b) ):
   print ("2 - a 和 b 有相同的标识")
else:
   print ("2 - a 和 b 没有相同的标识")
# 修改变量 b 的值
b = 30
if ( a is b ):
   print ("3 - a 和 b 有相同的标识")
else:
   print ("3 - a 和 b 没有相同的标识")
if ( a is not b ):
   print ("4 - a 和 b 没有相同的标识")
else:
   print ("4 - a 和 b 有相同的标识")

10运算符优先级

运算符	描述
(expressions…), [expressions…], {key: value…}, {expressions…}	圆括号的表达式
x[index], x[index:index], x(arguments…), x.attribute	读取，切片，调用，属性引用
await x	await 表达式
**	乘方(指数)
+x, -x, ~x	正，负，按位非 NOT
*, @, /, //, %	乘，矩阵乘，除，整除，取余
+, -	加和减
<<, >>	移位
&	按位与 AND
^	按位异或 XOR
\|	按位或 OR
in,not in, is,is not, <, <=, >, >=, !=, ==	比较运算，包括成员检测和标识号检测
not x	逻辑非 NOT
and	逻辑与 AND
or	逻辑或 OR
if — else	条件表达式
lambda	lambda 表达式
:=	赋值表达式

#!/usr/bin/python3
a = 20
b = 10
c = 15
d = 5
e = 0
e = (a + b) * c / d       #( 30 * 15 ) / 5
print ("(a + b) * c / d 运算结果为：",  e)
e = ((a + b) * c) / d     # (30 * 15 ) / 5
print ("((a + b) * c) / d 运算结果为：",  e)
e = (a + b) * (c / d)    # (30) * (15/5)
print ("(a + b) * (c / d) 运算结果为：",  e)
e = a + (b * c) / d      #  20 + (150/5)
print ("a + (b * c) / d 运算结果为：",  e)

and拥有更高优先级

x = True
y = False
z = False
if x or y and z:
    print("yes")
else:
    print("no")

11.False等价

对象/常量	值
“”	假
“string”	真
0	假
>=1	真
<=1	真
()空元组	假
[]空列表	假
{}空字典	假
None	假

12.表达式

由数字、符号、括号、变量等的组合。有算数表达式、逻辑表达式、赋值表达式、lambda表达式等等。
Python中,赋值既定义。Python是动态语言,只有赋值才会创建一个变量,并决定了变量的类型和值。
如果一个变量已经定义,赋值相当于重新定义。

13.内嵌函数

内建函数	函数签名	说明
print	print(value,…,sep=’’,end=’\n’)	将多个数据输出到控制台,默认使用空格分隔、\n换行
input	input([prompt])	在控制台和用户交互,接受用户的输入,并返回字符串
int	int(value)	将给定的值,转换成整数,int本质是类
str	str(value)	将给定的值,转换成字符串。str本质是类
type	type(value)	返回对象的类型。本质是元类
isinstance	isinstance(ibj,class_or_tuple)	比较对象的类型,类型可以是obj的基类isinstance(a, int)
range	range(start, stop[, step])	range函数可创建一个整数列表,是惰性的,一般用在 for 循环中。

14.程序控制

顺序
- 按照先后顺序一条条执行
分支
- 根据不通的情况判断,条件满足执行某条件下的语句
循环
- 例如满足就反复执行,不满足就不执行或不在执行
  14.1单分支
```python if condition: 代码块

if 1<2: #if True print(‘1 less than 2’)


- condtion必须是bool类型,这个地方有一个隐式转换bool(condition),相当于False等价于
- if语句这行最后,会有一个冒号,冒号之后如果有多条语句的代码块,会另起一行,并缩进
   - if、for、def、class等关键字后面都可以跟代码块
   - 这些关键后面,如果有一条语句,也可以跟在这一行后面,例如if 1>2: pass(pass什么也不做,只是为了占位)
<a name="FsaV9"></a>
## 14.2多分支
```python
if condtion1:
    代码块
elif condition2:
    代码块
elif condition3:
    代码块
else:
    代码块
#例子
a = 5
if a<0:
    print('neative')
elif a==0:
    print('zero')
else:
    print('positive')

多分支结构,只要有一个分支被执行,其他分支都不会被执行

前一个条件被测试过,下一个条件相当于隐含着这个条件

#嵌套
if a = 5:
  print('zero')
else:
  if a>0:
      print('positive')
  else:
      print('negative')

14.3while循环

while循环多用于死循环,或者不明确知道循环次数的场景

while cond:
  block
#死循环
while True:
  pass
#例
a = 10
while a:
  print(a)
  a -= 1

14.4for循环

for element in iteratable: #可迭代 对象中有元素可以迭代,进入循环体
  block
#列子
for i in range(0, 10):
  print(i)

14.5continue/break/pass

continue是退出本次循环
break 退出循环体
pass: 不做任何事情,一般用作占位语句

count = 0
for i in range(7, 1000, 7):
  print(i)
  count +=1
  if count >=20:
      print(count)
      break
#pass
count = 0
if count == 0:
  pass
else:
  print("不等于0")

continue和break是循环的控制语句,只影响当前循环,包括while、for循环
如果循环嵌套,containue和break也只影响语句所在的那一层循环
continue和break只影响循环,所以if cond: brak不是跳出if,而是种植if外的brak所在的循环
分支和循环结构可以嵌套使用,可以嵌套多层
14.6else字句
如果循环正常结束,else子句会被执行,即使是可迭代啊对象没有什么元素可迭代 ```python for i in range(0): pass else: print(‘ok’)

for i in range(0, 10): break else: print(“ok”)

for i in range(0, 10): continue esle: print(‘ok’)


<a name="yptSS"></a>
## 14.6三元表达式
在Python中,也有类似C语言的三木运算符构成的表达式,但python中的三元表达式不支持复杂的语句
```python
真值表达式 if 条件表达式 else 假值表达式
#输出 if 条件 else 假输出

value = input('>>')
if value:
    print(value)
else:
    print("empty")
#三元表达式
value = input('>>')
print(value) if value: else print('empty')
#三元
value = input(">>>")
print(value if value else 'empty')

作业一: 九九乘法表

#方法一:
i = 1
j = 1
while i <= 9:
    while j <= i:
        print(f"{j}X{i}={i*j}",end="\t")
        j+=1
    print()
    j=1
    i+=1
#方式二
for i in range(1,10):
    for j in range(1,10):
        if j <= i:
            print(j,"X",i,"=",j*i,end="\t",sep="")
    print()
#方法三
for i in range(1,10):
    for j in ranfor i in range(1,10):
    for j in range(1,10):
        if j<=i:
          print("{}*{}={:<{}}".format(j,i,j*i, 3 if j != 1 else 2),end="" if i != j else "\n")ge(1,i+1):
        print("{}*{}={}".format(j,i,j*i),end="\t",sep="")
    print()
#简洁方法
for i in range(1,10):
    for j in range(1,i+1):
        print("{}*{}={:<{}}".format(j,i,j*i, 3 if j != 1 else 2),end="" if i != j else "\n")
#倒三角for i in range(1,10):
    for j in range(1,i+1):
        print("{}*{}={:<{}}".format(j,i,j*i, 3 if j != 1 else 2),end="" if i != j else "\n")
for m in range(1,10):
    for n in range(m,10):
        #print("{}*{}={}".format(m, n, m*n), end=" ")
        print(str(m)+"*"+str(n)+"="+str(m*n),end="\t")
    print("\n")
#倒三角
for i in range(-9,0):
    for j in range(1,10):
         if(j==i*(-1)):
             print(j,"*",i*(-1),"=",i*j*(-1))
             break
         else:
             if(i*j*(-1)>9):
                 print(j,"*",i*(-1),"=",i*j*(-1),end="  ")
             else:
                 print(j,"*",i*(-1),"=",i*j*(-1),end="   ")
#倒三角
for i in range(-9,0):
    for j in range(1,10):
        if j<=i*(-1):
            print(j,"*",i*-1,"=",j*(i*-1),end="\t")
    print()

作业二:登录认证

count = 0
while count <= 3:
    user = input("用户名")
    passwd = input("密码")
    if user == "admin" and passwd == "123":
        print("登录成功")
        break
    else:
        print("用户或者密码错误请重新输入")
        count += 1
    if count == 3:
        print("错误三次,已经锁定")
        break
#for循环
for i in range(3):
    user = input("用户名")
    passwd = input("密码")
    if user == "admin" and passwd == "123":
        print("登录成功")
        break
    else:
        print("账户或者密码错误,请重新输入")
else:
    print("输入错误三次,账户已锁定")

编程语言

基础语法

1.注释

井号开头为注释

2.数字

3.字符串

4.转移序列

5.缩进

6.续行

7标识符

7.1标识符

7.2常量

7.3字面常量

7.4变量

7.5标识符本质

8语言类型

8.1静态编译型语言

8.2动态编译语言

9.运算符

9.1算数运算符