一、Python基础(语法规范,数据类型,运算符等)

1 Markdown常用基本语法

1.1 标题

在文字前加#则代表#的个数不同,标题的级别也就不同,后面在加上个空格

  • 一级标题 #
  • 二级标题 ##
  • 三级标题 ###
  • 四级标题 ####

1.2 文字效果

1.2.1 加粗

语法:**文本**

1.2.2 斜体

语法:*文本*

1.2.3 斜体加粗

语法:***文本***

1.2.4 ~~删除线~~

语法:~~文本~~

1.2.5 引用

语法:`人生苦短,Python当歌` 

1.2.6 表格

语法: 表头|表头|表头 ----|----|--- 内容|内容|内容 内容|内容|内容

v2-e7d317a9b5323201608ee954a64e272d_b.png

1.2.7 不需要运行的代码块可以用反引号(数字1左边的按键)括起来

语法: ``` 被引用的代码块 ```

```
a = 1
if a > 0:
    print('正数')
elif a < 0:
    print('负数')
else:
    print('零')
```

2 Python代码语法

2.1 查看函数帮助文档

print()  
# shift + tab 查看帮助文档方法一

?print  
#查看帮助文档方法二

help(print)
#通过help函数查看函数帮助文档

一、Python基础(语法规范,数据类型,运算符等)_第1张图片

2.2 注释

  • 在 Python 中,# 表示注释,作用于整行。
# 这是一个单行注释
# 快捷键为Ctrl+/,注意快捷键每次都对整行进行注释,如果一行内既有需要运行的代码又有需要注释的文字时,谨慎使用
  • ''' ''' 或者 """ """ 表示区间注释,在三引号之间的所有内容被注释
'''
这是多行注释
单引号或者双引号都可以
但是单双引号不能混用
'''

'\n这是多行注释\n单引号或者双引号都可以\n但是单双引号不能混用\n'

2.2.1 print()函数

print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
  • 将对象以字符串表示的方式格式化输出到流文件对象file里。其中所有非关键字参数都按str()方式进行转换为字符串输出;
  • 关键字参数sep是实现分隔符,比如多个参数输出时想要输出中间的分隔字符;
  • 关键字参数end是输出结束时的字符,默认是换行符\n
  • 关键字参数file是定义流输出的文件,可以是标准的系统输出sys.stdout,也可以重定义为别的文件;
  • 关键字参数flush是立即把内容输出到流文件,不作缓存。

print是打印的意思,在这里指的是向屏幕上输出指定的文字

print 可以打印单个值,也可以打印多个值,还可以设置以什么字符作为多个值之间的分隔.

print('Hello World')

Hello World

print('Hello', 'World', sep = '***') #设置分隔符

Hello***World

print('Hello', 'World',sep = ' *** ',end = ' &') #设置结束符

Hello *** World &


有多少个print函数,都可以一起显示

print("                            _ooOoo_                     ")
print("                           o8888888o                    ")
print("                           88  .  88                    ")
print("                           (| -_- |)                    ")
print("                            O\\ = /O                    ")
print("                        ____/`---'\\____                ")
print("                      .   ' \\| |// `.                  ")
print("                       / \\||| : |||// \\               ")
print("                     / _||||| -:- |||||- \\             ")
print("                       | | \\\\\\ - /// | |             ")
print("                     | \\_| ''\\---/'' | |              ")
print("                      \\ .-\\__ `-` ___/-. /            ")
print("                   ___`. .' /--.--\\ `. . __            ")
print("                ."" '< `.___\\_<|>_/___.' >'"".         ")
print("               | | : `- \\`.;`\\ _ /`;.`/ - ` : | |     ")
print("                 \\ \\ `-. \\_ __\\ /__ _/ .-` / /      ")
print("         ======`-.____`-.___\\_____/___.-`____.-'====== ")
print("                            `=---='  ")
print("                                                        ")
print("         .............................................  ")
print("                  佛祖镇楼             BUG辟邪          ")

一、Python基础(语法规范,数据类型,运算符等)_第2张图片

多行字符可以用三对引号

print("""                           
                            _ooOoo_                     
                           o8888888o                   
                           88  .  88                   
                           (| -_- |)                    
                            O\ = /O                    
                        ____/`---'\\____                
                       .   ' \| |// `.                  
                        / \||| : |||// \\               
                     / _||||| -:- |||||- \\             
                        | | \\\\\\ - /// | |             
                     | \_| ''\\---/'' | |              
                      \ .-\\__ `-` ___/-. /            
                    ___`. .' /--.--\\ `. . __            
                ."" '< `.___\\_<|>_/___.' >'"".         
               | | : `- \`.;`\\ _ /`;.`/ - ` : | |     
                  \ \ `-. \\_ __\\ /__ _/ .-` / /      
          ======`-.____`-.___\\_____/___.-`____.-'====== 
                            `=---='  

         .............................................  
                  佛祖镇楼             BUG辟邪         """)

一、Python基础(语法规范,数据类型,运算符等)_第3张图片

2.3 变量和赋值

  • 在使用变量之前,需要对其先赋值。
  • 变量名可以包括字母、数字、下划线、但变量名不能以数字开头。
  • Python 变量名是大小写敏感的,foo != Foo。
  • Python中用赋值语句的方式赋值一个变量,不需要显式声明变量的数据类型,Python解释器根据所赋值的数据类型自动确定变量的类型
teacher = "CrescentAI的程序人生"
print(teacher)

CrescentAI的程序人生

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

5

first, second = second, first # 交换两个变量的赋值
print(first, second)

3 2

2.3.1 变量可以被重复赋值

  • Python是动态类型语言
  • 对同一个变量可以重复赋值,而且重新赋值的数据类型可以和最开始赋值的数据类型不同
  • 注意,由于对同一个变量可以重复赋值,所以在使用变量前,确定好变量的赋值内容
  • 变量可以被重复赋值的原因:变量赋值实际上是变量对值的一个引用,而不是变量的取值
print(teacher)

CrescentAI的程序人生

teacher = 'CrescentAI的程序人生'
print(teacher)

CrescentAI的程序人生

# 删除变量
del teacher
print(teacher)

一、Python基础(语法规范,数据类型,运算符等)_第4张图片

2.3.2 变量命名规范

  • 变量名只能包含字母 数字和下划线
  • 变量名可以以字母和下划线开头,但不能以数字开头
  • Python中的关键字和函数名不可以作为变量名使用
  • 实际工作中,变量的命名尽量能体现变量的性质,例如:score_class5 这个变量名说明变量被赋值的是5班的成绩
6a = 7 #数字不可以做变量名的开头

_6a = 7 #下划线可以做为变量名的开头

True = 2  #关键字不能做变量名

2.3.3 查看Python关键字

import keyword
keyword.kwlist # 这些关键字全部不能作为变量名使用

一、Python基础(语法规范,数据类型,运算符等)_第5张图片

2.4 Python语句书写规范

2.4.1 Python语句中没有专门的"结束符"

Python解释器不是根据"结束符"来判断语句是否结束,而是根据语法的完整性来判断

2.4.2 Python语句编写规则

  • 通常是一行一句
  • 也可以一行多句,用语句分隔符";"对两个语句进行标识
  • 也可以一句多行,有时候语句过长,一行放不下,用续行符"\"进行标识
x1 = 1
x2 = 2
x3 = 3
print(x1,x2,x3)

1 2 3

x1 = 1;x2 = 2;x3 = 3;print(x1,x2,x3)

1 2 3

x1 = 1  x2 = 2  x3 = 3  print(x1,x2,x3) #不加分号会报错

v2-aed6b2f61204ea31170104d9f7bdccd9_b.jpg
print("中心极限定理说明,在适当的条件下,大量相互独立随机变量的均值经适当标准化后依分布收敛于正态分布。这组定理是数理统计学和误差分析的理论基础,指出了大量随机变量之和近似服从正态分布的条件。")

中心极限定理说明,在适当的条件下,大量相互独立随机变量的均值经适当标准化后依分布收敛于正态分布。这组定理是数理统计学和误差分析的理论基础,指出了大量随机变量之和近似服从正态分布的条件。

print("中心极限定理说明,在适当的条件下,大量相互独立随机变量的均值经适当标准化后依分布收敛于正态分布。   
      这组定理是数理统计学和误差分析的理论基础,指出了大量随机变量之和近似服从正态分布的条件。")  
#不加续行符直接换行会报错

一、Python基础(语法规范,数据类型,运算符等)_第6张图片
print("中心极限定理说明,在适当的条件下,大量相互独立随机变量的均值经适当标准化后依分布收敛于正态分布。\
      这组定理是数理统计学和误差分析的理论基础,指出了大量随机变量之和近似服从正态分布的条件。")

中心极限定理说明,在适当的条件下,大量相互独立随机变量的均值经适当标准化后依分布收敛于正态分布。 这组定理是数理统计学和误差分析的理论基础,指出了大量随机变量之和近似服从正态分布的条件。

print("""中心极限定理说明,在适当的条件下,大量相互独立随机变量的均值经适当标准化后依分布收敛于正态分布。
      这组定理是数理统计学和误差分析的理论基础,指出了大量随机变量之和近似服从正态分布的条件。""")  #多行文本也可以用三对引号实现换行

中心极限定理说明,在适当的条件下,大量相互独立随机变量的均值经适当标准化后依分布收敛于正态分布。
这组定理是数理统计学和误差分析的理论基础,指出了大量随机变量之和近似服从正态分布的条件。

重要的缩进

  • python语言最大特色是强制用空白符(white space)作为语句缩进,缩进开始之处,必须加冒号":"
  • 代码的缩进与对齐方式很重要,同一个层级的代码缩进方式应一致,即"对齐"
  • 一个模块的界限,完全是由每行的首字符在这一行的位置来决定的 (而C语言是用一对花括号{}来明确的定出模块的边界的,与字符的位置毫无关系)
  • 通过强制程序员们缩进(包括if,for和函数定义等所有需要使用模块的地方), Python确实使得程序更加清晰和美观。
i = 0
for j in range(5):
    i = i+j
    print(j,i)

v2-eb94352de54b3be92e5a010a228d4ea6_b.png
#去掉缩进会报错提醒需要缩进
i = 0
for j in range(10):
i = i+j
print(j,i)

v2-f74decde213b2e56d95cb7bb30a94fd1_b.jpg

一、Python基础(语法规范,数据类型,运算符等)_第7张图片

3 数据类型与转换

一、Python基础(语法规范,数据类型,运算符等)_第8张图片

一、Python基础(语法规范,数据类型,运算符等)_第9张图片

3.1 查看数据类型

3.1.1 获取类型信息 type(object)

print(type(1))

print(type(5.2))

print(type(True))

print(type('5.2'))

3.1.2 获取类型信息 isinstance(object, classinfo)

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()

3.2 类型转换

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

int

str(a) #返回视图

'1'

b = str(a)
b

'1'

type(b)

str

4 运算符

4.1 算数运算符

下面以a=10 ,b=20为例进行计算

一、Python基础(语法规范,数据类型,运算符等)_第10张图片

4.2 关系运算符

一、Python基础(语法规范,数据类型,运算符等)_第11张图片

赋值运算符

一、Python基础(语法规范,数据类型,运算符等)_第12张图片
k = 5
j = 4
j += k  #等价于j = j+k
j

9

逻辑运算符

一、Python基础(语法规范,数据类型,运算符等)_第13张图片
3 > 2 and 3 < 5

True

1 > 3 and 2 < 1

False

1 > 3 or 3 < 5

True

4.5 位运算符

一、Python基础(语法规范,数据类型,运算符等)_第14张图片

4.5.1 原码、反码和补码

二进制有三种不同的表示形式:原码、反码和补码,计算机内部使用补码来表示。

原码:就是其二进制表示(注意,第一位是符号位,其余位表示值)

0000 0011 = 3
1000 0011 = -3

反码:正数的反码就是原码,负数的反码是符号位不变,其余位取反(对应正数按位取反)

0000 0011 = 3
1111 1100 = -3

补码:正数的补码就是原码,负数的补码是反码+1

0000 0011 = 3
1111 1101 = -3

符号位:最高位为符号位,0表示正数,1表示负数。在位运算中符号位也参与运算

4.5.2 按位非操作 ~

~1 = 0
~0 = 1

~num的补码中的 0 和 1 全部取反(0 变为 1,1 变为 0)有符号整数的符号位在~ 运算中同样会取反

 0000 0101 = 5
~1111 1010 = -6

 1111 1011 = -5
~0000 0100 = 4

4.5.3 按位与操作 &

1 & 1 = 1
1 & 0 = 0
0 & 1 = 0
0 & 0 = 0

只有两个对应位都为1时才为 1

"""
0000 0101 & 0000 0110
5 & 6


0000 0100
4
"""

print(5 & 6)

4

4.5.4 按位或操作 |

1 | 1 = 1
1 | 0 = 1
0 | 1 = 1
0 | 0 = 0

只要两个对应位中有一个1时就为 1

"""
0000 0101 | 0000 0110
5 | 6


0000 0111
7
"""

print(5 | 6)
7

4.5.5 按位异或操作 ^

1 ^ 1 = 0
1 ^ 0 = 1
0 ^ 1 = 1
0 ^ 0 = 0

只有两个对应位不同时才为1

"""
0000 0101 ^ 0000 0110
5 ^ 6


0000 0011
3
"""

print(5 ^ 6)
3

异或操作的性质:满足交换律和结合律

A = 0000 1100
B = 0000 0111

A ^ B = 0000 1011
B ^ A = 0000 1011

A ^ A = 0000 0000
A ^ 0 = 0000 1100

A ^ B ^ A = A ^ A ^ B = B = 0000 0111

4.5.6 按位左移操作 <<

num << inum的二进制表示向左移动i位所得的值

"""
0000 1011 = 11
11 << 3

0101 1000
88
"""

print(11 << 3)

88

4.5.7 按位右移操作 >>

num >> inum的二进制表示向右移动i位所得的值

"""
0000 1011 = 11
11 >> 2

0000 0010
2
"""

print(11 >> 2)

2

4.5.8 利用位运算实现快速计算

通过 <<>> 快速计算2的倍数问题

n << 1 -> 计算 n*2
n >> 1 -> 计算 n/2,负奇数的运算不可用
n << m -> 计算 n*(2^m),即乘以 2 的 m 次方
n >> m -> 计算 n/(2^m),即除以 2 的 m 次方
1 << n -> 2^n

通过 ^ 快速交换两个整数

a ^= b
b ^= a
a ^= b

通过 a & (-a) 快速获取 a 的最后为 1 位置的整数

"""
0000 0101 & 1111 1011
5 & -5


0000 0001
1
"""
print(5 & -5)

1

"""
0000 1110 & 1111 0010
14 & -14


0000 0010
2
"""

print(14 & -14)

2

4.5.9 利用位运算实现整数集合

一个数的二进制表示可以看作是一个集合(0 表示不在集合中,1 表示在集合中)。

比如集合 {1, 3, 4, 8},可以表示成 01 00 01 10 10 而对应的位运算也就可以看作是对集合进行的操作。

4.5.9.1 元素与集合的操作:

a | (1< 把 i 插入到集合中
a & ~(1< 把 i 从集合中删除
a & (1< 判断 i 是否属于该集合(零不属于,非零属于)

4.5.9.2 集合之间的操作

a 补   -> ~a
a 交 b -> a & b
a 并 b -> a | b
a 差 b -> a & (~b)

注意:整数在内存中是以补码的形式存在的,输出自然也是按照补码输出

【例子】Python中的bin()输出

bin(3)

'0b11'

bin(-3)

'-0b11'

bin(-3 & 0xffffffff)

'0b11111111111111111111111111111101'

bin(0xfffffffd)

'0b11111111111111111111111111111101'

0xfffffffd

4294967293

是不是很颠覆认知,我们从结果可以看出:

  • Python中bin一个负数(十进制表示),输出的是它的原码的二进制表示加上个负号,巨坑。
  • Python中的整型是补码形式存储的。
  • Python中整型是不限制长度的不会超范围溢出。

所以为了获得负数(十进制表示)的补码,需要手动将其和十六进制数0xffffffff进行按位与操作,再交给bin()进行输出,得到的才是负数的补码表示。

4.6 其它运算符

一、Python基础(语法规范,数据类型,运算符等)_第15张图片
letters = ['A', 'B', 'C', 'D', 'E', 'F', 'G']

if 'A' in letters:
    print('A' + ' exists')

if 'h' not in letters:
    print('h' + ' not exists')

A exists
h not exists

#比较两个变量均指向不可变类型
a = "hello"
b = "hello"
print(a is b, a == b)

True True

#比较两个变量均指向可变类型
a = ["hello"]
b = ["hello"]
print(a is b, a == b)

False True

注意:

  • is, is not 对比的是两个变量的内存地址
  • ==, != 对比的是两个变量的值

即:

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

运算符的优先级

  • 一元运算符优于二元运算符。例如3 ** -2等价于3 ** (-2)
  • 先算术运算,后移位运算,最后位运算。例如 1 << 3 + 2 & 7等价于 1 << (3 + 2)) & 7
  • 逻辑运算最后结合。

4.7 python内置的一些计算函数:

一、Python基础(语法规范,数据类型,运算符等)_第16张图片

python还提供科学计算等库,例如math,导入math库后,常用的函数有:

一、Python基础(语法规范,数据类型,运算符等)_第17张图片

,返回值类型是浮点数|

5 参考文献:

Datawhale github.com/datawhalechi
runoob.com/python3/pyth
bilibili.com/video/av40
mp.weixin.qq.com/s/DZ58
cnblogs.com/OliverQin/p

6 练习题

6.1 怎样对python中的代码进行注释?

  • 单行注释
# 定义一个字符串
a = 'Welcome to the beautiful world'
a

'Welcome to the beautiful world'

  • 多行注释
'''
这是多行注释,用三个单引号,打印:Welcome
这是多行注释,用三个单引号,打印:to
这是多行注释,用三个单引号,打印:the
这是多行注释,用三个单引号,打印:china
连成一句话
'''
print('Welcome to the china')

Welcome to the china

"""
这是多行注释,用三个双引号
这是多行注释,用三个双引号
打印一段小明与大明的对话
"""
print('小明:Hello')
print('大明:Hi')
print('小明:大明,this is 中明')
print('中明:Nice to me you')
print('大明:Nice to me you too')

小明:Hello
大明:Hi
小明:大明,this is 中明
中明:Nice to me you
大明:Nice to me you too

6.2 python有哪些运算符,这些运算符的优先级是怎样的?

以下表格列出了从最高到最低优先级的所有运算符:

一、Python基础(语法规范,数据类型,运算符等)_第18张图片

6.3 python 中 is, is not==, != 的区别是什么?

  • is 用于判断两个变量引用对象是否为同一个(同一块内存空间), == 用于判断引用变量的值是否相等
  • is not 用于判断两个变量是否引用自不同的对象,而 != 用于判断引用变量的值是否不等

6.4 python 中包含哪些数据类型?这些数据类型之间如何转换?

一、Python基础(语法规范,数据类型,运算符等)_第19张图片
a = 1
print(a, type(a))

1

b = str(a)
print(b, type(b))

1

c = float(a)
print(c, type(c))

1.0

6.5 给定一个非空整数数组,除了某个元素只出现一次以外,其余每个元素均出现两次。找出那个只出现了一次的元素。

尝试使用位运算解决此题

一、Python基础(语法规范,数据类型,运算符等)_第20张图片

一、Python基础(语法规范,数据类型,运算符等)_第21张图片
from typing import List
from functools import reduce
class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        return reduce(lambda x, y: x ^ y, nums)
Solution.singleNumber(self = 0, nums = [2,2,1])

1

Solution.singleNumber(self = 0, nums = [4,1,2,1,2])

4

def singleNumber(self, nums: List[int]) -> int:
    a = 0
    for i in nums:
        a ^= i
    return a
singleNumber(self = a,nums = [2,2,1])

1

singleNumber(self = a,nums = [4,1,2,1,2])

4

源代码:
github.com/CrescentRuby

你可能感兴趣的