第一阶段：Python开发基础 第二周知识点汇总（包含第一周总结）

目录

计算机基础之编程

什么是编程语言

人与计算机交流的介质

什么是编程

通过编程语言编写一大堆文件

为什么要编程

奴役计算机,帮我们干活

计算机五大组成

CPU

控制器

控制硬件

运算器

算术运算+逻辑运算

内存

优点: 速度快

缺点: 断电即消失, 存储容量小

外存

优点: 永久存储, 容量大

缺点: 速度慢

输入设备

输入信息,如 键盘/鼠标

输出设备

输出信息, 如 显示器/打印机

IO设备

u盘, 它既可以输入信息,又可以输出信息

32位和64位

32位是计算机一次性读取32个字节; 64位是计算机一次性读取64个字节, 向下兼容

多核CPU

多个大脑,可以同时做多件事情

应用程序的启动

  1. 双击qq(寻找qq的路径)
  2. 操作系统控制cpu
  3. cpu控制内存从硬盘中读取qq数据
  4. 启动

机械硬盘工作原理

机械手臂

读取数据

磁道

存储数据

扇区

划分磁道

平均寻道时间

5ms, 机械手臂到磁道的时间

平均延迟时间

4.15ms ,以7200r/min的电脑举例,

平均寻找数据时间

9.15ms

计算机操作系统

什么是文件

操作系统提供的虚拟单位

什么是应用程序

一堆文件

操作系统有什么用

把对硬件的复杂操作简单化,提供接口

计算机的三大组成

硬件

和操作系统交互

操作系统

应用程序/硬件/用户

应用程序

操作系统

用户

操作系统

操作系统的启动

  1. 开机
  2. 启动临时操作系统
  3. 临时操作系统找到真正的操作系统并启动
  4. 关闭临时操作系统

编程语言的分类

机器语言

优点(较汇编语言):执行效率高

缺点(较汇编语言):开发效率低

汇编语言

优点(较机器语言):开发效率高

缺点(较机器语言):执行效率低

高级语言

编译型语言(谷歌翻译)

优点(较解释型语言):执行效率高

缺点(较解释型语言):开发效率低

解释型语言(同声传译)

优点(较编译型语言):开发效率高 方便调试

缺点(较编译型语言):执行效率低 解释器都是拿编译型语言做的

网络的瓶颈效应

网络延迟的时间远远大于程序运行的时间,程序运行的时间就可以忽略不计

操作系统这样的软件不需要网络,所以一般拿编译型语言创建

执行Python程序的两种方式

交互式

cmd

命令行式

python test.py

变量

什么是变量

描述世间万物的变化的状态

变量名的定义规则

  1. 变量名具有描述意义
  2. 不能使用关键字
  3. 使用字母/数字/下划线组成,首字母不能使用数字

变量的组成

变量名

接收变量值(没有引号的就一定是变量名)

赋值符号

赋值作用

变量值

具体的数据类型

定义变量名的两种风格

驼峰体

NickOfAge

下划线(推荐使用)

nick_of_age

常量

不变的量,全大写,但是在Python中是可以变化的,只是程序员约定俗成的

python变量内存管理

引用计数

变量值被引用,引用计数加1

垃圾回收机制

变量值引用计数为0的时候,释放变量值

小整数池

[-5,256]之间的整数在python解释器启动的时候就被创建,永远不会被垃圾回收机制回收

定义变量的三个特征

x = 10

打印值

print(x)

获取内存地址

print(id(x))

获取数据类型

print(type(x))

花式赋值

链式赋值

a = b = 10

交叉赋值

x, y = y, x

注释

单行注释

# 注释

解释/让#后面的东西无意义

多行注释

''' '''

换行注释

与用户交互

input

三种格式化输出方式

%占位符

'%s'%'nick'

format格式化

'{}'.format('nick')

f-string格式化

f'{"nick"}'

基本运算符

算术运算符

+-*/ // % **

逻辑运算符

and

or

not

比较运算符

> >= < <= == !=

赋值运算符

= += -= *= /= //= **= %=

身份运算符

is

is not

成员运算运算符

in

not in

运算符的优先级

需要优先的加上()

流程控制之if判断

单分支结构

if

双分支结构

if

else

多分支结构

if

elif

...

elif

else

if嵌套

if

​ if

流程控制之while循环

while + break

跳出循环,终止循环

while + continue

跳出本次循环

while + else

循环没有被break掉就执行else内部代码

while嵌套

while

while

流程控制之for循环

for + break

跳出循环

for + continue

跳出本次循环

for + else

循环没有被break掉执行else内部代码

for循环嵌套

for

​ for

range

range(10) = [0,1,2,3,4,5,6,7,8,9]

数字类型

整型int

  1. 定义方式
  2. a = 10
    2. a = int('10')
  3. 使用方法
    1. +-*/ // % **

浮点型float

  1. 定义方式
    1. a = 10.0
    2. a = float('10.0')
  2. 使用方法
    1. +-*/ // % **

字符串str

  1. 定义方式
    1. s = 'nick' ; s = "nick" ; s = "nick's" ; s = 'nick"s'
    2. s = '''nick nick'''
  2. 使用方法
    1. 优先掌握
      1. 索引
      2. 切片
      3. 长度
      4. 成员运算
      5. for循环
      6. strip
      7. split
    2. 需要掌握
      1. rstrip/lstrip
      2. startswith/endswith
      3. upper/lower
      4. join
      5. rsplit
      6. replace
      7. isdigit/isalpha
    3. 了解
      1. find/rfind/index/rindex/count
      2. capitalize/swapcase/title
      3. center/ljust/rjust/zfill
      4. is系列

列表list

  1. 定义方式: []内逗号隔开多个元素(任意数据类型)
  2. 使用方法
    1. 优先掌握
      1. 索引取值,索引修改值
      2. 切片
      3. 成员运算
      4. 长度
      5. for循环
      6. append
      7. del删除
    2. 需要掌握
      1. insert
      2. pop
      3. remove
      4. count
      5. find
      6. index
      7. extend
      8. sort
      9. reverse
      10. clear
      11. copy
      12. ...

字典dict

  1. 定义方式: {}内以逗号隔开键值对,key(具有描述意义,不能为可变数据类型):value(具体的任意数据类型)
  2. 使用方法
    1. 优先掌握
      1. 按key取值,按key修改值,按key增加值
      2. 成员运算
      3. 长度
      4. for循环
      5. keys/values/items
      6. del 删除
      7. get
    2. 需要掌握
      1. copy
      2. update
      3. clear
      4. setdefault
      5. fromkeys
      6. pop(按key删除)
      7. popitem(随机删除,但是删除最后一个)

元组tuple

  1. 定义方式: ()内以逗号隔开多个任意数据类型的元素
  2. 不可更改的列表,创建后就只能是那样了

集合set

1. 定义方式: {}内以逗号隔开多个元素(不能为可变数据类型)
  1. 使用方法:
    1. 优先掌握
      1. &
      2. |
      3. -
      4. ^
      5. 成员运算
      6. 长度
      7. for循环
      8. add
    2. 需要掌握
      1. 傻逼才记得

布尔类型bool

  1. True
  2. False

条件判断后触发,一般不单独使用

有序or无序

有索引的有序,无索引的无序

可变or不可变

值变id不变,可变; 值变id也变,不可变

数据类型分类

可变or不可变

可变 不可变
列表/字典/集合 整型/浮点型/字符串/元组

有序or无序

有序 无序
字符串/列表/元组 字典/集合

一个值or多个值

一个值 多个值
整型/浮点型/字符串 列表/元组/字典/集合

解压缩

a, b, c = [1, 2, 3]

Python深浅拷贝

只针对可变数据类型

拷贝(赋值)

当lt2为lt的拷贝对象,lt的所有数据类型元素变化,lt2也变化

浅拷贝

当lt2为lt的浅拷贝对象,lt内的不可变数据类型变化,lt2不变化; lt内的可变数据类型变化,lt2变化

深拷贝

当lt2为lt的深拷贝对象,lt内的所有数据类型元素变化,lt2不变化

异常处理

try...except

try:
    代码块
except Exception as e:
    print(e)

assert

assert 1==1

条件成立跳过, 不成立报assertError断言错误

raise

主动抛出异常

字符编码

以什么格式存储就以什么格式读取

Python2和3字符编码的区别

代码详情 Python2执行情况 Python3执行情况
# coding:gbk
print('中')
终端：utf8		 乱码 不乱码
# coding:utf8
print('中')
终端：utf8		 不乱码 不乱码
# coding:gbk
print(u'中')
终端：utf8		 不乱码
# coding:utf8
print(u'中')
终端：utf8		 不乱码

文件的基本操作

  1. 打开文件 open
  2. 读写文件 read/write
  3. 关闭文件 close

文件的三种打开模式

r模式

只读

w模式

只写,清空后写入

a模式

追加写入

with管理文件上下文

with open() as fa,\
	open() as fw: 
    	fa.

文件的高级应用

文件的高级打开模式(不推荐使用)

  1. r+
  2. a+
  3. w+

文件指针的移动方法(不推荐使用)

  1. seek字节
    1. 0文件头
    2. 1当前位置
    3. 2文件末
  2. tell字节
  3. read(n)字符
  4. truncate(n)字节, 截断文本
    1. truncate(0) 清空文件

文件的修改

方式一

with open('test.py','r',encoding='utf8') as fr,\
	open('test_swap.py','w',encoding='utf8') as fw:
        data = fr.read()	
        # data逻辑修改
        fw.write(data)

import os
os.remove('test.py')
os.rename('test_swap.py','test.py')

方式二

with open('test.py','r',encoding='utf8') as fr,\
	open('test_swap.py','w',encoding='utf8') as fw:
        for i in fr:
            # i逻辑修改
            fw.write(i)

import os
os.remove('test.py')
os.rename('test_swap.py','test.py')

函数的定义

def 函数名(参数1,参数2,...):
    return 返回值

函数的三种定义方式

无参函数

没有参数的函数

有参函数

有参数的函数

空函数

pass

函数的返回值

return 除了能返回值 ,终止函数

返回多个值,用元组形式返回

函数的调用

函数名()

函数的参数

形参

具有描述意义

位置形参

从左到右一个一个写

默认形参

位置形参具有默认值, 默认形参必须在位置形参后面

实参

具体的数据类型

位置实参

从左到右一个一个给形参传值

关键字实参

按照形参名传值, 关键字实参在位置实参后面

可变长参数

*

形参

*args用元组的形式接收多余的位置实参,

实参

打散元组然后将打散的值一个一个传值给形参

**

形参

**kwargs用字典的形式接收多余的关键字实参

实参

打散字典然后将打散的值传给形参

dic = {'a':1,'b':2}

a=1,b=2

函数对象

  1. 引用
  2. 作为函数的参数
  3. 作为函数的返回值
  4. 作为容器元素

函数的嵌套

def f1():
    def f2():
        pass

名称空间与作用域

名称空间

内置名称空间

python解释器启动的时候生成,如 len/int/dict

全局名称空间

文件执行的时候生成

局部名称空间

函数调用的时候生成

执行顺序

内置-->全局-->局部

查找顺序

从当前开始 --> 局部-->全局-->内置

作用域

全局作用域

全局+内置空间定义的变量

x = 1

def f1():
    x = 3
f1()
print(x)  # 1
    
x = 1 和 x = 3的两个x毫无关系

局部作用域

局部空间定义的变量,不同的函数具有不同的作用域

def f1():
    x = 1
    def f2():
        x = 3
    print(x)
    
f1()  # 1
x = 1 和 x = 3的两个x毫无关系

总结

全局作用域内的变量和局部作用域内的变量就算变量名相同也毫无关系 ; 不同函数的局部作用域内的变量就算变量名相同也毫无关系

global

x = 1

def f1():
    global x
    x = 3
  
f1()
print(x)  # 3

nonlocal

def f1():
    x = 1
    def f2():
        nonlocal x
        x = 3
    print(x)
    
f1()  # 3

可变类型

lt = [1,2,3]

def f1():
  lt.append(4)  
  
f1()
print(lt)  # [1,2,3,4]
posted @ 2019-08-12 21:02  foreversun92  阅读(129)  评论(0)  编辑  收藏  举报