Python基础（上）

前一段时间一直在学习Python基础，但是学的也是杂乱无章，忘的也比较快，今天特别抽时间把学习的笔记整理出来一部分，基本上都是参考马士兵Python的b站课程顺序整理出来的

1. print打印

  • 功能：向目的地输出内容
  • 输出的内容：数字、字符串、表达式
  • 目的地：LDLE（集成开发环境）、控制台、文件

2. 转义字符

2.1 什么是转义字符

就是反斜杠+想要实现的转义功能首字母

2.2 为什么需要转义字符

当字符串中包含反斜杠、单引号和双引号等有特殊用途的字符时，必须使用反斜杠对这些字符进行转义（转换一个含义）

  • 反斜杠 \\
  • 单引号 \‘
  • 双引号 \“

当字符串中包含换行、回车、水平制表符或者退格等无法直接表示的特殊字符时，也可以使用转义字符

  • 换行 \n newline换行首字母
  • 回车 \r 回车会把前面的覆盖掉print('hello \r world')，这里的打印出world，回车会把hello覆盖
  • 水平制表符 \t 制表符从前到后开始数，四个为一个制表位
  • 退格 \b 退一格，会把上一个字符退格删了

2.3 原字符

原字符：不希望字符串中的转义字符起作用，就使用原字符， 就是在字符串之前加上R或者r

注意事项：最后一个字符不能是反斜杠

1
>print(r'hello\nworld\')

最后只有一个字符是反斜杠就会报错，如果是两个反斜杠就没有问题

1
print(r'hello\nworld')		#则打印出来显示的为”hello\nworld“

3. 二进制和字符编码

8bit(位)=1byte(字节) 1024byte=1kb 1024kb=1mb 1024mb=1gb 1024gb=1t

机器语言只能识别0和1

基本的汉字和一些符号有ASII表

在中国有GB2312、GBK、GB18030等一些编码，在国外有其他国家的字符编码

但是Unicode几乎包含了全世界的字符、他就是UTF-8编码

4. 标识符和保留字

4.1 保留字

有一些单词被赋予了特定的意义，这些单词在给任何对象起名字的时候都不能用到

1
2
3
4
5
6
None       break      except     in         raise
True       class      finally    is         return
and        continue   for        lambda     try
as         def        from       nonlocal   while
assert     del        global     not        with
async      elif       if         or         yield

1. True、False

False 布尔类型的值，表示假，与True相反 True 布尔类型的值，表示真，与False相反

2. and、or、not

逻辑运算符 与、或、非

3.class

定义类的关键字

4.is、in

Python中的对象包含三个要素：id，type，value 其中：

  • id:用来唯一标识一个对象
  • type：标识对象的类型
  • value：是对象的值

is：就是用来判断a对象是否就是b对象，是通过id来判断的

==：判断的是a对象的值是否和b对象的值相等，是通过value来判断的

in：判断变量是否存在序列中

5.try、except、finally、raise

使用try...except...finally语句来处理异常。

  • 通常的语句块放在try块中
  • 错误处理的语句放在except块中
  • 始终执行的语句放在finally块中
  • raise 语句抛出一个指定的异常。
1
2
3
4
5
6
7
8
9
10
11
try:        
    #some code here        
    raise MyException      
except MyException:        
    print("MyException encoutered") 
finally:        
    print("Arrive finally")
    
x = 10
if x > 5:
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))

6.if、elif、else

判断语句，if语句用来检验一个条件，如果条件为真，运行一块语句(称为if…块)，否则处理另外一块语句（称为else…块）。else从句是可选的

7.def、global、nonlocal、return、yield

  • def 定义函数的关键字
  • global 定义全局变量
  • nonlocal 在局部寻找外层函数中离他最近的那个变量
  • return 函数中的返回值
  • yield的用法有点像return,除了它返回的是一个生成器
1
2
3
4
def createGenerator():
    mylist = range(3)
    for i in mylist:
        yield i*i

8.for、while

for循环可以遍历任何序列的项目，如一个列表或者一个字符串 while循环可以通关判断条件真假无限循环

9.break、continue

  • break语句是用来终止循环语句，即使哪怕循环条件没有称为false或者序列还没有被完全递归，也会停止循环
  • continue语句被用来跳过当前循环块中的剩余语句，继续进行下一轮循环

10.assert

assert 关键字用于在代码中设置检查点，用于当程序出现错误时中断程序执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> a = 3
>>> assert 0 < a < 10
>>> a = 20
>>> assert 0 < a <10
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    assert 0 < a <10
AssertionError
 
# assert 条件后可以增加错误信息解释
>>> a = 20
>>> assert 0 < a < 10, '超出范围！'
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    assert 0 < a < 10, '超出范围！'
AssertionError: 超出范围！

11.del

del删除变量或者序列的值

1
2
3
a = [-1,3,'aa',85] # 定义一个list      
del a[0] # 删除第0个元素      
del a[2:4] # 删除从第2个到第3个元素。

12.import、from、 as

用于导包，as为重命名

1
from turtle import fd as f

13.with

用于文件的读写

1
2
3
# 写文件
with open("test.txt", "wt") as out_file:
    out_file.write("公众号：一行数据，没想到吧，这里有植入")

14.pass

pass空的类，函数，方法的占位符

15.await、async

async 用来声明一个函数为异步函数，异步函数的特点是能在函数执行过程中挂起，去执行其他异步函数，等到挂起条件（假设挂起条件是sleep(5)）消失后，也就是5秒到了再回来执行。

await 用来用来声明程序挂起，比如异步程序执行到某一步时需要等待的时间很长，就将此挂起，去执行其他的异步程序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
async def test2(i):
     r = await other_test(i)
     print(i,r)
 
async def other_test(i):
     r = requests.get(i)
     print(i)
     await asyncio.sleep(4)
     print(time.time()-start)
     return r
 
url = ["https://segmentfault.com/p/1210000013564725",
        "https://www.jianshu.com/p/83badc8028bd",
        "https://www.baidu.com/"]
 
loop = asyncio.get_event_loop()
task = [asyncio.ensure_future(test2(i)) for i in url]
start = time.time()
loop.run_until_complete(asyncio.wait(task))
endtime = time.time()-start
print(endtime)
loop.close()

16.lambda

通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用，也就是匿名函数

<函数名> = lambda <参数> : <表达式>

1
2
f = lambda x, y, z: x+y+z  #f是表达式的名字
>>> f(1,2,3)  #像函数一样调用

4.2 标识符

  • 变量、函数、类、模块和其他对象的起的名字都叫标识符
  • 规则
    • 字母、数字、下划线_
    • 不能以数字开头
    • 不能是python保留字
    • 严格区分大小写

通过程序可以将所有保留字打印出来

1
2
3
4
5
6
import keyword
print(keyword.kwlist)23

#输出结果
['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

5. 变量

变量就是内存中一个带标签的盒子

变量由三部分组成

  • 标识：表示对象所存储的内存地址，使用内置函数id(obj)来获取
  • 类型：表示的是对象的数据类型，使用内置函数type(obj)来获取
  • 值：表示对象所存储的具体数据，使用print(obj)可以将值进行打印输出
1
2
3
4
5
6
7
8
name = "张志鹏"
print("标识：", id(name))
print("类型：", type(name))
print("值", name)

#标识： 2222422933936
#类型： <class 'str'>
#值 张志鹏

当多次赋值之后，变量名会指向新的空间

6. 数据类型

常用的数据类型

数据类型 表示 举例
整数类型 int 98
浮点数类型 float 3.14159
布尔类型 bool TURE、FALSE
字符串类型 str 人生苦短，我用python

6.1 整数类型

  • 英文为integer，简写为int，可以表示为正数、负数和零
  • 整数的不同进制表示方式
    • 十进制—>默认的进制
    • 二进制—>以0b开头
    • 八进制—>以0o开头
    • 十六进制—>以0x开头

6.2 浮点类型

  • 浮点数由整数部分和小数部分组成

  • 浮点数存储不精确性

    • 使用浮点数进行计算时，可能会出现小数位数不确定的情况

      1
      2
      print(1.1+2.2) #3.3000000000000003
      print(1.1+2.1) #3.2

    • 解决方案

      • 导入模块decimal

        1
        2
        from decimal import Decimal
        print(Decimal('1.1')+Decimal('2.2'))

6.3 布尔类型

  • 用来表示真或假的值

  • True表示真，False表示假

  • 布尔值可以转化为整数

    • True—>1
    • False—>0
    1
    2
    print(True+1) #2
    print(False+1) #1

6.4 字符串类型

  • 字符串又被称为不可变的字符序列
  • 可以使用单引号、双引号、三引号来定义
  • 单引号和双引号定义的字符串必须在一行
  • 三引号定义的字符串可以分布在连续的多行
1
2
3
4
5
6
7
8
9
10
11
12
13
str1 = '人生苦短，我用python'
str2 = "人生苦短，我用python"
str3 = '''人生苦短
我用python'''
print(str1)
print(str2)
print(str3)
#人生苦短，我用python

#人生苦短，我用python

#人生苦短
#我用python

6.5 数据类型转换

将不同数据类型的数据拼接在一起

函数名 作用 注意事项 举例
str() 将其他数据类型转换成字符串 也可用于引号转换 str(123)—>’123’
int() 将其他数据类型转换成整数 1.文字类和小数类字符串，无法转换成整数
2.浮点数转换成整数，抹零取整		 int(‘123’)
int(9.8)
float() 将其他数据类型转换成浮点数 1.文字类无法转成整数
2.整数转成浮点数，末尾为.0		 float(‘9.9’)
float(9)

7. 注释

  • 在代码中对代码的功能进行解释说明的标注性文字，可以提高代码的可读性
  • 注释的内容会被Python解释器忽略
  • 通常包括三种类型的注释
    • 单行注释——>以#开头，直到换行结束
    • 多行注释——>将一对三括号（‘’‘或者"""）注释
    • 中文编码声明注释——>在文件开头加上中文声明注释，用以指明编码文件的编码格式

8. input函数

作用：接收来自用户的输入

返回值类型：输入值的类型为str

值的存储：使用=对输入的值进行存储

1
2
3
4
5
6
#输入函数input
present=input('大圣想要什么礼物呢？')
print(present,type(present))

#大圣想要什么礼物呢？定海神针
#定海神针 <class 'str'>
1
2
3
4
5
6
7
# 从键盘录入两个整数，计算两个整数的和
a = input('请输入一个加数')
a = int(a)      # 将转换之后的结果存储到a中
b = input('请输入另一个加数')
b = int(b)
print(a+b)
# 也可以直接a = int(input('请输入一个加数'))

9. 常用运算符

9.1 算术运算符

  1. 标准算术运算符 加（+）、减（-）、乘（*）、除（/）、整除（//）

    取整（一正一负向下取整） 9//-4或者-9//4的答案都是-3，由-2向下取整为-3

  2. 取余运算符 %

    取余（一正一负要公式） 余数=被除数-除数*商

    9%-4结果为-3 9-(-4)*(-3)=9-12=-3

    -9%4结果为3 -9-(4)*(-3)=-9+12=3

  3. 幂运算符 **

9.2 赋值运算符

执行顺序：从右到左

支持链式赋值 a=b=c=20

支持参数赋值 +=、-=、*=、/=、//=、%=

支持系列解包赋值 a,b,c=20,30,40

9.3 比较运算符

>、<、>=、<=、!= 返回值为True、False

== 对象value的比较

is、is not 对象的id的比较

其中，一个 = 称为赋值运算符，== 称为比较运算符

一个变量由三部分组成，标识，类型，值

== 比较的是值还是标识呢？ 比较的是值

比较对象的标识使用 is 和 is not

下面由两个例子供参考

1
2
3
4
a = 10
b = 10
print(a == b)	# True	说明，a与b的value    相等
print(a is b)	# True	说明，a与b的id标识	  相等	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
lst1 = [11, 22, 33, 44]
lst2 = [11, 22, 33, 44]
print(lst1 == lst2)     # value  -->True
print(lst1 is lst2)     # id -->False
print(id(lst1))
print(id(lst2))

'''
输出结果
True
False
1351505079360
1351504973504
'''

9.4 布尔运算符

布尔运算符主要是对于布尔值之间的运算

包括 and 、or 、not 、in 、not in

  • 运算符and 当两个运算数都为True时，运算结果才为True
  • 运算符or 只要有一个运算数为True，运算结果就为True
  • 运算符not 如果运算数为True，运算结果为False，反之
  • 运算符in 表示在不在里面，下面用例子演示一下
1
2
3
s = 'helloworld'
print('w' in s)		# True，表示字符w在变量s里面出现
print('k' in s)		# Flase，表示字符k不在变量s里面出现

9.5 位运算符

在做位运算的操作时候一定要先把数据转换成二进制再进行计算

位运算符 操作
位与 & 对应数位都是1，结果数位才是1，否则是0
位或 ` `
左移运算符<< 高位溢出舍弃，低位补0
右移运算符>> 低位溢出舍弃，高位补0

9.6 运算符的优先级

优先级依次为：

** 幂运算符号

*,/,//,% 乘除、取余

+,- 加减

算术运算：先算乘除，后算加减，有幂运算，先算幂运算

<<,>> 左移位、右移位运算符

& 位与

| 位或

位运算：先算移位，再算位与和位或

>,<,>=,<=,==,!= 大于小于、比较

比较运算：结果集为True、False

and 布尔运算符

or 布尔运算符

布尔运算：对上一步结果集进行布尔运算

= 最后再是赋值运算符

10 程序的组织结构

程序的结构一般都分为顺序结构、选择结构和循环结构，此处和本人学过的C语言、C++语言以及Java语言相识，都是同为三种基本结构

10.1 顺序结构

顺序结构，顾名思义，就是按照一定的顺序来执行语言程序，在python中，就是按照自上到下的顺序来执行程序，又比如在赋值运算中就是从右到左，按着一定的优先级的顺序来执行赋值运算。

10.2 对象的布尔值

在进行下面两种结构总结之前，应该先介绍一下对象的布尔值

  • Python一切皆对象，所有对象都有一个布尔值
    • 获取对象的布尔值，就要使用到内置函数bool()
  • 以下对象的布尔值为False
    • False
    • 数值0
    • None
    • 空字符串
    • 空列表 []、list()
    • 空元组 ()、tuple()
    • 空字典 {}、dict()
    • 空集合 set()

10.3 选择结构

选择结构，就是程序根据判断条件的布尔值选择性地执行部分代码，明确的让计算机在什么条件下，该去做什么

语法结构通常有单分支结构、双分支结构、多分支结构、嵌套if结构

语法结构：

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
28
29
#单分支结构
if 条件表达式:
    条件执行体1
    条件执行体2

#双分支结构
if 条件表达式:
    条件执行体1
else:
    条件执行体2
    
#多分支结构
if 条件表达式1:
    条件执行体1
elif 条件表达式2:
    条件执行体3
elif 条件表达式N:
    条件执行体N
else:
    条件执行体N+1
    
#嵌套if结构
if 条件表达式1:
    if 内层条件表达式:
        内层条件执行体1
    else:
        内层条件执行体2
else:
    条件执行体

选择结构中可以简写成条件表达式if....else，：【条件为真的结果】if 条件 else 【条件为假的结果】

下面以一个例子来参考一下用法

1
2
3
4
5
6
7
8
9
10
#比较大小
if num_a>=num_b:
    print(num_a,'大于等于',num_b)
else:
    print(num_a,'小于',num_b)

#使用条件表达式进行比较
print( (num_a,'大于等于',num_b)	if num_a>=num_b else  (num_a,'小于',num_b))
#或者将打印出来的东西化简
print( str(num_a)+'大于等于'+str(num_b)	 if num_a>=num_b else  str(num_a)+'小于'+str(num_b)  )

此外，在Python中还有一点与其他语言不相同之处

在C与Java中，表示两个数之间的范围通常只能用score > 80 && score < 90

但是在Python中，表示两个数之间的范围可以用两种表达方式score > 80 and score < 90或者直接80 < score < 90，此处的&&也换成了Python中布尔运算符的and，并且可以直接用数学中连等的方式来表示

10.4 pass语句

pass语句：语句什么都不做，只是一个占位符，用在语法上需要语句的地方

pass语句可以用在：先搭建语法结构，还没想好代码怎么写的时候

关于什么语法可以一起使用：

  • if语句的条件执行体
  • for-in语句的循环体
  • 定义函数时的函数体

下面是使用方式，以if语句作为例子参考学习

1
2
3
4
5
if a>b:
    pass
else:
    pass
#此时的代码是没有报错的，但是也不会执行出结果，有种类似于只为了不报错也不想看到出格的结果的感觉

10.5 range()函数

在总结循环结构之前还是需要先写一下range()函数的用法，因为可能后面的for循环会经常用到这个函数

range()函数：就是用来生成一个整数序列

  • 创建range对象有三种方式，后面会有相关代码例子介绍

    • range(stop)
    • range(start,stop)
    • range(start,stop,step)

  • range()函数的返回值是一个迭代器对象

  • range类型的优点

  • 不管range对象表示的整数序列有多长，所有range对象占用的内存空间都是相同的，因为仅仅需要存储start,stop和step，只有当用到range对象时，才会去计算序列中的相关元素

  • in 与 not in 可以判断整数序列中是否存在（不存在）指定的整数

下面就一个例子，简单描述一下range()函数的一些创建方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# rang()的三种创建方式
"""第一种创建方式：只有一个参数（小括号里面只给了一个数字）"""
r = range(10)       # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]，默认从0开始，默认相差1称为步长
print(r)            # range(0, 10)
print(list(r))      # 用于查看range对象种的整数序列  ——>list是列表的意思

"""第二种创建方式：给了两个参数（小括号里面给了两个数字）"""
r = range(1, 10)    # 指定了起始值，从1开始，到10结束（不包括10），默认步长为1
print(list(r))      # [1, 2, 3, 4, 5, 6, 7, 8, 9]

"""第三种创建方式：给了三个参数（小括号里面给了三个数字）"""
r = range(1, 10, 2) # 指定了起始值，从1开始，到10结束（不包括10），指定了步长为2
print(list(r))      # [1, 3, 5, 7, 9]

"""判断指出的整数 再序列中是否存在 用in， not in"""
print(10 in r)      # False， 10不在当前的r这个整数序列 中
print(9 in r)       # True， 9在当前的r这个序列中

10.6 循环结构

循环结构就是指反复做一件事情

循环结构一般有while、for -in

选择结构的if与循环结构while的区别

  • if是判断一次，条件为True执行一次
  • while是判断N+1次，条件为True执行N次

while的语法结构

1
2
while 条件表达式:
    条件执行体(循环体)

while的一个万金油例子，计算1-100之间的偶数和

1
2
3
4
5
6
7
8
a = 0
sum = 0
while a <= 100:
    if a % 2 == 0:
        sum += a
    a += 1
print('1-100之间的偶数和为', sum)
#输出结果：1-100之间的偶数和为 2550

for-in循环

  • in表达从（字符串、序列等）中依次取值，又称为遍历
  • for-in遍历的对象必须是可迭代对象

for-in的语法结构

1
2
for 自定义的变量 in 可迭代对象:
    循环体

另外，循环体内不需要访问自定义变量，可以将自定义变量替代为下划线

下面以几个代码例子演示一下for-in的用法

1
2
3
4
5
6
7
8
9
10
11
12
13
for item in 'Python':    # 第一次取出来的是P，将P赋值给item，将item的值输出
    print(item)
# 输出结果依次为 P  y  t  h  o  n

# range()产生一个整数序列 -->也是一个可迭代对象
for i in range(10):
    print(i)
# 输出结果依次为 0  1  2  3  4  5  6  7  8  9

# 如果在循环体中不需要使用到自定义变量，可将自定义变量写成”_“
for _ in range(5):
    print('人生苦短，我用Python')
# 输出结果为循环五次 人生苦短，我用Python

10.7 流程控制语句

break语句：用于结束循环结构，通常与分支结构if一起使用

continue语句：用于结束当前循环，进入下一次循环，通常与分支结构中的if一起使用

通常在多重循环中的break和continue只用于控制本层的循环

此处提到的控制语句break和continue其实与C语言中的作业一样，都是结束循环和结束本次循环的意思

10.8 else语句

else语句在前面的if...else中有讲到，但是它其实有这三种搭配方式，所以单独提出来再总结一些东西

else可以与if配合使用，但是if条件表达式不成立的时候才能执行else

else也可以和while、for配合使用，但是只有当没有碰到break的时候才执行else

下面列举几个例子方便理解使用

1
2
3
4
5
6
7
8
9
for item in range(3):
    pwd = input('请输入你的密码：')
    if pwd == '8888':
        print('密码正确')
        break
    else:       # 此处的else是与上面的if搭配使用的，如果if执行成功，就不会再执行else
        print('密码不正确')
else:           # 此处的else是与最上面的for搭配使用的，如果没有遇到break，那么else就一定会被执行
    print('对不起，三次密码均输入错误')
1
2
3
4
5
6
7
8
9
10
11
12
a = 0
while a < 3:
    pwd = input('请输入你的密码：')
    if pwd == '8888':
        print('密码正确')
        break
    else:       # 此处的else是与上面的if搭配使用的，如果if执行成功，就不会再执行else
        print('密码不正确')
    a+=1
else:           # 此处的else是与最上面的while搭配使用的，如果没有遇到break，那么else就一定会被执行
    print('对不起，三次密码均输入错误')

由此可见，其实else的用法和C语言的其实也不太一样，但是代码其实从上到下按照本身的逻辑走一遍，这里面的else是与谁搭配使用的就很好被理解了

10.9 嵌套循环

嵌套循环在前面几个知识点的例子中都有涉及到，只是没有指出来细细讲解

其意义就是：循环结构中又嵌套了另外的完整的循环结构，其中内层循环作为外层循环的循环体执行

下面就直接举一个打印九九乘法表的代码例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
for item in range(1, 10):
    for it in range(1, item+1):
        print(it, '*', item, '=', item*it, end='\t')
    print('\n')
    
"""
1 * 1 = 1	
1 * 2 = 2	2 * 2 = 4	
1 * 3 = 3	2 * 3 = 6	3 * 3 = 9	
1 * 4 = 4	2 * 4 = 8	3 * 4 = 12	4 * 4 = 16	
1 * 5 = 5	2 * 5 = 10	3 * 5 = 15	4 * 5 = 20	5 * 5 = 25	
1 * 6 = 6	2 * 6 = 12	3 * 6 = 18	4 * 6 = 24	5 * 6 = 30	6 * 6 = 36	
1 * 7 = 7	2 * 7 = 14	3 * 7 = 21	4 * 7 = 28	5 * 7 = 35	6 * 7 = 42	7 * 7 = 49	
1 * 8 = 8	2 * 8 = 16	3 * 8 = 24	4 * 8 = 32	5 * 8 = 40	6 * 8 = 48	7 * 8 = 56	8 * 8 = 64	
1 * 9 = 9	2 * 9 = 18	3 * 9 = 27	4 * 9 = 36	5 * 9 = 45	6 * 9 = 54	7 * 9 = 63	8 * 9 = 72	9 * 9 = 81	
"""

果然啊，用Python写九九乘法表就是很容易，比起C语言和Java的双层for循环，这个似乎简单了不少

由于时间的原因，也没有整理出来特别多的知识点，所以只整理到了这里，有些知识点的细节部分可能没有讲清楚，后续有时间还会接着整理出中、下部分。

Python
日常学习 Python

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议 ，转载请注明出处！