Python基础语法_python ++

1 标识符

• 标识符就是对变量、常量、函数、类等对象起的名字。
• 命名规则(基础，重要)

1. 严格区分大小写
2. 只能以 字母 数字 下划线 组成(数字不能开头)
3. 见名知意
4. 蛇式\小驼峰\大驼峰命名法
5. 变量小写，常量大写
6. 不能以关键字作为标识符

Python保留字

Python保留字，也叫关键字，是Python语言官方确定的用作语法功能的专用标识符，不能把它们用作任何自定义标识符名称。关键字只包含小写字母。可以通过python提供的库输出这些关键字

• Python的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字

1 >>>import keyword
2 >>>keyword.kwlist
1
2

2 注释

我们写的程序里，不光有代码，还要有很多注释。注释有说明性质的、帮助性质的，它们在代码执行过程中相当于不存在，透明的。

• 增加代码可读性
• 1.单行注释
  # --> CTRL+/

1 # 打印输出hello world
2 print("hello world")
1
2

Ctrl+d复制当前行

• 2.多行注释
  Python没有真正意义上的多行注释（块注释）语法。
  选中需注释的代码，再使用快捷键CTRL+/*

1 # 第一行注释
2 # 第二行注释
3 # 第三行注释
1
2
3

• 3.注释文档(文本注释)
  在某些特定的位置，用三对引号包括起来的部分，也被当做注释。

 1 """
 2     这个是函数的说明文档。
 3     :param a: 加数
 4     :param b: 加数
 5     :return: 和
 6 """
 7 '''
 8     也可以实现多行注释
 9     与三个双引号作用一致
10 '''
1
2
3
4
5
6
7
8
9
10

• 注意:
  很多时候，我们在一些py脚本文件的开头都能看到类似的以#开头的这样两行代码，它们不是注释，是一些设定

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
1
2

• 第一行：用于指定运行该脚本的Python解释器，Linux专用，windows不需要。env方式下，系统会自动使用环境变量里指向的Python。还有一种方式，#!/usr/bin/python3.6，这会强制要求使用系统中的python3.6解释器执行文件，这种方式不好，一旦你本地的Python3.6版本删除了，会出现找不到解释器的错误。无论两种方式的哪一种，都指的是在linux下使用
• 第二行：代码的编码方式。不是程序要处理的数据的编码方式，而是程序自己本身的字符编码。在Python3中，全面支持Unicode，默认以UTF-8编码，我们不用再纠结中文的问题，乱码的问题，所以本行其实可以不需要。但在Python2中，对字符的编码是个非常令人头疼的问题，通常都需要指定这么一行。如果要自定义别的编码类型的话，可以像这样：# – coding: cp-1252 --，但如果没有强制需求的话，不要自己作死，请坚持使用utf-8编码。
• 这里的-*-是什么意思呢？没意思，装饰美观好看而已。

3语句与缩进

• 语句
  在代码中，能够完整表达某个意思、操作或者逻辑的最短代码，被称为语句。

1 a = 321
2 print("hello world")
3 input("请输入")
1
2
3

注意：python的标准语言不需要使用分号。简单的换行就表示语句已经结束。

• 代码块
  为完成某一特定功能而联系在一起的一组语句构成一个代码块。有判断、循环、函数、类等各种代码块。代码块的首行通常以关键字开始，以冒号( : )结束。比如：

1 if expression:
2     pass
3 elif expression :
4     pass
5 else:
6     pass
1
2
3
4
5
6

• 缩进
  Python最具特色的语法就是使用缩进来表示代码块，不需要使用大括号
  像PHP、JAVA等语言都是使用（{}）来表示代码块的。python一般用四个空格就是tab来缩进。在pycharm中tab自动回转成4个空格。在Linux环境中，如VIM编辑器，建议使用空格。
  那么怎么才是正确的缩进方式呢？
  • 所有的普通语句，顶左开始编写，不需要缩进
  • 所有的语句块，首行不用缩进，从冒号结束后开始下一行，都要缩进
  • 直到该语句块结束，就退回缩进，表示当前块已结束
  • 语句块可以嵌套，所以缩进也可以嵌套
  多行语句： 前面是多条语句在一行，但如果一条语句实在太长，也是可以占用多行的，可以使用反斜杠( \ )来实现多行语句

1 string = "i love this country,"\
2         +"because it is very beautiful!"\
1
2

不到迫不得已，不要使用这种，该换行就换行。

• pass语句
  pass语句是占位语句，它什么都不做，只是为了保证语法的正确性而写。以下场景中，可以使用pass语句：
  • 当你不知道后面的代码怎么写的时候
  • 当你不需要写代码细节的时候
  • 当语法必须，又没有实际内容可写的时候
  • 其它的一些你觉得需要的场景

1 def func(a,b):
2     pass
1
2

• 字符串的表示形式
  abc可能是个变量，但是 “abc” 肯定是个字符串。(在编程语言中，所有的符号都是英文状态下的。)
  在python中单引号和双引号的作用完全相同。(在其他语言中，单双引号还是有一定区别的。)
  原生字符串： 通过在字符串前加r或R，如 r"this is test \n"，表示这个字符串里的斜杠不需要转义，等同于自身

• 以换行作为语句的结束

• shift + tabe 顶格

4 变量与常量

• 变量与常量都是容器
• 变量是可变的，常量(全部大写)是不可变的
• 变量创建 name = “tly”

1. 开辟"tly"字符串对象
2. 创建了 name 这个变量，并且指向了 “tly”
3. id() -->内存地址

• 创建变量无需声明类型
• 在Python中使用全部大写来辨别常量。
  但Python中没有保护常量的机制所以也没用严格意义上的常量

5 输入与输出

5.1 input输入函数

• input()是内置函数，用来获取用户输入。

input()输入返回的都是字符串

• 输入name为tly，返回的是string类型的’tly’

1 >>> name = input("请输入你的名字:")
2 请输入你的名字:tly
3 >>> name
4 'tly'
5 >>> type(name)
6 <class 'str'>
1
2
3
4
5
6

• 输入age为21，返回的是string类型的’21’

1 >>> age = input("请输入你的年龄:")
2 请输入你的年龄:21
3 >>> age
4 '21'
5 >>> type(age)
6 <class 'str'>
1
2
3
4
5
6

• 输入回车，返回的是’'空字符串

1 >>> ipt = input("请输入:")
2 请输入:
3 >>> ipt
4 ''
5 >>> type(ipt)
6 <class 'str'>
1
2
3
4
5
6

• 输入a and b，返回的是保留了空格格式的字符串

1 >>> ipt = input("请输入:")
2 请输入:'a and b'
3 >>> ipt
4 "'a and b'"
5 >>> type(ipt)
6 <class 'str'>
1
2
3
4
5
6

以上代码可以看出，输入的值不管是什么，类型都是字符串。

• type()是python内置的函数之一，作用是查看数据的类型。
• str.isdigit(): 判断字符串是否全部为数字组成

阻塞或暂停程序

1 print("程序前面部分执行完毕......")
2 input("请按回车继续......")       # 在这里程序会暂停，等待你的回车动作
3 print("继续执行程序的后面部分......")
1
2
3

此时的input函数不会将输入的值保存下来，只是用作暂停程序动作

• 对于形如“123”， “283242”的字符串，转化没问题，但是对于包含字符、特殊字符的字符串就没办法转化了，会弹出异常错误。所以在使用int函数之前，要先对输入进行判断。

1 age = input("请输入你的年龄：  ")
2 if int(age)>18:   # 强转
3     print("你好呀，小靓仔")   
4 else:
5     print("你好呀，小盆友")
1
2
3
4
5

5.2 print输入函数

• print() 方法用于打印输出，是最常见的一个函数。
  语法:print(self, *args, sep=' ', end='\n', file=None)
  常用参数
• sep：分隔符符号，在值之间插入的字符串，默认为空格

1 print('你好','世界',sep='。。')
2 
3 你好。。世界
1
2
3

• end：字符串追加在最后一个值之后，默认为换行符\n。如果，设置end=’ '，则可以不换行，让print在一行内连续打印。活用print的参数，可以实现灵活的打印控制。

1 print("你好")
2 print("世界")
3 
4 print("你好",end=',')
5 print("世界")
6
7 你好
8 世界
9 你好,世界
1
2
3
4
5
6
7
8
9

print格式化输出

• 在Python2.6以后，有两种格式化输出的方式。

1. 一种就是类似C语言的printf的%百分号格式化输出，也是Python最基础最常用的格式化输出方式。
2. 另一种就是str.format()的方式。

• %格式化输出
  这里先介绍一下传统的%格式化输出方式，例如：

age=18
print("tly的年龄为:",age)
print("tly的年龄为:"+str(age))

tly的年龄为: 18
tly的年龄为:18

age=18
sex="male"
print("tly的年龄为%d,性别为%s"%(age,sex))
print("tly的年龄为",age,",","性别为男性",sex)

tly的年龄为18,性别为male
tly的年龄为 18 , 性别为男性 male
``

首先构造了一个字符串"我叫%s 今年%d岁"，讲其中需要用别的变量替换的部分，用%号加一个数据类型代号，前面有多少个%号，后面就要提供多少个参数，每个参数值之间用逗号隔开。每个参数与前面的%，相对应的。并且数据类型也要能够合法对应。
- 格式化符号
![在这里插入图片描述](https://img-blog.csdnimg.cn/2021012922253871.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RsdGZs,size_16,color_FFFFFF,t_70)

需要特别说明的是，如果你想在print中打印一个%百分符号本身，那么你需要使用%%，两个百分符转义出一个百分符

```python
1 age=21 
2 print('%d%%'%age)
3 21%
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

4.运算符

• 运算符：以1 + 2为例，1和2被称为操作数，"+" 称为运算符。
  Python语言支持以下类型的运算符:

1. 算术运算符
2. 比较（关系）运算符
3. 赋值运算符
4. 逻辑运算符
5. 位运算符
6. 成员运算符
7. 身份运算符
8. 三目运算符

4.1 算术元运算符

以下假设变量： a=10，b=20：

• 需注意的地方：

1. /计算结果是浮点数，即使两个数都是整数，结果也是浮点数

1 >>> 9/3     
2 3.0
3 >>> 10/3
4 3.3333333333333335
5 10/3不应该是3.3333333333333333333333无限循环吗？那实际上是因为计算机内存与cpu的有穷性导致结果为3.3333333333333335。
1
2
3
4
5

2. //只取整数部分，余数被抛弃

1 >>> 10//3   
2 3
3 >>> -10//3
4 -4  # 向下取整
1
2
3
4

3. %余数运算，可以得到两个整数相除的余数

1 >>> 10%3     
2 1
3 >>> -10%3
4 2   # 向下取整
1
2
3
4

4. 如果想同时得到商和余数，可以用divmod()这个方法
   该方法的返回值是tuple (x//y, x%y).

1 >>> divmod(10,3)    
2 (3,1)
1
2

5. 因为浮点数精度的问题，Python还存在一些计算方面的小问题

1 0.1+0.1+0.1-0.3
2 5.551115123125783e-17
1
2

要解决这个问题，可以导入decimal模块

1 from decimal import Decimal
2 Decimal('0.1')+Decimal('0.1')+Decimal('0.1')-Decimal('0.3')
3 Decimal('0.0')
1
2
3

4.2 比较运算符

需注意的地方：

1. 返回值为bool值

1 >>> True == 1
2 True
3 >>> False == 0
4 True
1
2
3
4

2. ==比较数值（int与str不能直接比较）

1 >>> 2.0 == 2
2 True
3 >>> '2' == 2
4 False
1
2
3
4

3. != <>不等于

• python3中(python3中<>已弃用)

1 >>> a = 1
2 >>> b = 2
3 >>> a != b
4 True
5 >>> a <> b
6   File "<stdin>", line 1
7    a <> b
8       ^
9 SyntaxError: invalid syntax
1
2
3
4
5
6
7
8
9

• python2中

1 >>> a = 1
2 >>> b = 2
3 >>> a != b
4 True
5 >>> a <> b
6 True
1
2
3
4
5
6

4. 字符串与字符串之间是比较ASCII值

1 >>> 'abc' < 'xyz'   # 97 98 99 < 120 121 122
2 True
3 >>> (3,2) < ('a','b')   
4 Traceback (most recent call last):
5   File "<stdin>", line 1, in <module>
6 TypeError: '<' not supported between instances of 'int' and 'str'
1
2
3
4
5
6

5. 连续比较，python的解释机制

1 >>> 3 > 2 > 1   # 3 > 2 and 2 > 1
2 True
3 >>> 3 > 2 > 2   # 3 > 2 and 2 > 2
4 False
5 >>> (3 > 2) > 1 # True and True > 1
6 False
1
2
3
4
5
6

4.3 赋值运算符

1 >>> a = 1       # 将等号右边 赋值 等号左边
2 >>> a = a + 1   # 先等号右边计算 再赋值给 等号左边
3 >>> a += 1      # a = a + 1
1
2
3

1. python不支持a++语法

1 >>> a++         # python不支持a++语法
2   File "<stdin>", line 1
3     a++
4       ^
5 SyntaxError: invalid syntax
1
2
3
4
5

2. 注意+=不能拆开写 + =

1 >>> a + = 1     # 不能拆开写 + =
2   File "<stdin>", line 1
3     a + = 1
4         ^
5 SyntaxError: invalid syntax
1
2
3
4
5

4.4 位运算符

• 按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下： 下表中变量 a 为 60，b 为 13，二进制格式如下：

1 a = 0011 1100
2 b = 0000 1101
3 -----------------
4 a&b = 0000 1100
5 a|b = 0011 1101
6 a^b = 0011 0001
7 ~a  = 1100 0011
1
2
3
4
5
6
7

4.5 逻辑运算符

Python语言支持逻辑运算符，但是没有其它语言中的&&和||语法，取而代之的是更加人性化的英文单词and or not（全部都是小写字母）。以下假设变量 a 为 10, b为 20：

1. a and b 两者都为True时结果才为True
2. a or b 两者有一个为True则结果就为True

 1 >>> a = True
 2 >>> b = True
 3 >>> c = False
 4 >>> d = False
 5 >>> a and b
 6 True
 7 >>> a and c
 8 False
 9 >>> a or c
10 True
11 >>> c or d
12 False
1
2
3
4
5
6
7
8
9
10
11
12

3. 短路(懒惰)原则

1 False and True   # 懒惰,当and运算符时,遇到第一个为False则不会往后了
2 True or False    # 懒惰,当or运算符时,遇到第一个为True则不会往后了
1
2

4.6 成员运算符

in 与 not in是Python独有的运算符（全部都是小写字母），用于判断对象是否某个集合的元素之一，非常好用，并且运行速度很快。返回的结果是布尔值类型的True或者False。

练习：判断a是否在list1列表中

 1 list1 = [1, 2, 3, 4, 5]
 2 a = 1
 3 for i in list1:
 4     if i == a:
 5         print("a在list1中")
 6     else:
 7         print('a不在list1中')
 8 flag = False
 9 for i in list1:
10     if i == a:
11         flag = True
12         break
13 if flag:
14     print("a是list1的元素之一")
15 else:
16     print("a不是list1的元素")
17     
18    
19 # 如果用in运算符来做的话，就不用这么麻烦了
20 
21
22 list1 = [1, 2, 3, 4, 5]
23 a = 1
24 if a in list1:
25     print("a是list1的元素之一")
26 else:
27     print("a不是list1的元素")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

4.7 身份运算符

这也是Python的特色语法（全部都是小写字母）。

• 注意is与比较运算符==的区别，两者有根本上的区别，切记不可混用：

is用于判断两个变量的引用是否为同一个对象(可使用id()查看)，而==用于判断变量引用的对象的值是否相等！

 1 >>> a = [1,2,3]
 2 >>> b = [1,2,3]
 3 >>> a is b
 4 False
 5 >>> a == b
 6 True
 7 >>> a = 2
 8 >>> b = 2.0 # 可通过id()查看内存地址 
 9 >>> a is b  
10 False
11 >>> a == b
12 True
1
2
3
4
5
6
7
8
9
10
11
12

4.8 三目运算符

python中的三目运算符表示方法：True_statements if expression else False_statements
例如：

1 a = 1
2 b = 2
3 if a+b>3:
4     print(a+b)
5 else:
6     print(b-a)
7 a+b if a+b>3 else b-a   # 三目运算符
1
2
3
4
5
6
7

如果a+b大于3执行a+b,否则执行b-a

4.9 运算符优先级

下表列出了从最高到最低优先级的所有运算符。优先级高的运算符优先计算或处理，同级别的按从左往右的顺序计算（赋值运算符除外，它是按从右往左的顺序）