python课程笔记

计算机组成原理

什么是计算机

计算机（computer）俗称电脑，是现代一种用于高速计算的电子机器，可以进行数值计算，又可以进行逻辑判断，还具有记忆存储功能，且能够按照程序的运行，自动、高速处理数据。

计算机是20世纪最先进的科学技术发明之一。

计算机组成

一个完整的计算机系统，由硬件系统和软件系统两大部分组成。

硬件系统

主要分为主机和外设两部分，是指那些构成计算机系统的物理实体，它们主要由各种各样的电子器件和机电装置组成。

主机部分

• 中央处理器（CPU）

​ 运算器

​ 控制器

• 内存储器

​ 随机存储器（RAM Random Access Memory， 断电数据丢失）

​ 只读存储器（ROM Read–Only Memory）

外设部分

• 输入设备: 键盘、鼠标等…

• 输出设备：显示器、音响、打印机等…

• 外存储器：软盘、硬盘、U盘等…

软件系统

系统软件

操作系统（整合硬件资源）、驱动程序（提供接口给硬件设备）、语言处理程序、数据库管理系统等…

应用软件

浏览器、文本编辑器、音视频播放器…

计算机程序执行过程

按照冯·诺伊曼存储程序的原理，计算机的工作流程大致如下：

1、用户打开程序，程序开始执行（程序是存放在外存储器里面的）

2、操作系统将程序内容和相关数据送入计算机的内存（从外存储器加载到RAM上）

3、CPU根据程序内容从内存中读取指令

4、CPU分析、处理指令，并为下一条指令做准备

5、取下一条指令并分析、处理，如此反复，直至执行完程序中全部指令，最后将计算的结果放入指令指定的存储器地址中

Python基础

注释

作用：对代码起到解释说明的作用,注释内容不是真的代码,并不执行

• 单行注释

以 # 开头

# 我是注释

• 多行注释
  以三个三引号开头并结尾

'''
	我是注释
'''

快捷键

win：ctrl + /

mac：command + /

变量

暂存数据，使用前需要声明

变量定义与使用

num = 1 
print(a)

变量类型

变量类型获取

使用 type() 函数测试数据类型

num = 1
print(type(num)) # <class 'int'>

不可变数据类型

int 整数类型

1、2、3、100

float 浮点类型（小数、实数）

1.0、3.14、100.234243

str 字符串类型

单引号、双引号、三引号之内的内容

'' # 空字符串
' ' # 一个空格
'这是一个字符串'
"这也是一个字符串"
'''这还是一个字符串'''

可以用下标索引，下标从 0 开始

字符串遍历

• 方式一

for c in s:
    print(c)

• 方式二

i = 0
while i < len(s):
    print(s[i])
    i += 1

"""
    字符串逆序
"""


def rev_str(s):
    # 先定义一个空字符串用来拼接
    ans_str = ''

    # 用下标访问
    i = len(s) - 1
    while i >= 0:
        ans_str += s[i]
        i -= 1
    return ans_str


st = input('enter:')
print(rev_str(st))

字符串切片

切片：通过指定下标，可以获取字符串中的某一段字符，可以是负数。字符串、列表、元组都支持切片操作

语法：[起始：结束：步长]，不包含结束位本身

s = 'abcdefg'
print(s[:]) # 输出全部
print(s[1:]) # 从下标 1 开始到最后
print(s[:2]) # 从 0 开始到下标 2
print(s[::1]) # 步长默认为 1
print(s[::2]) # 相隔两个输出

# 步长可以取负值， 表示从右向左切，但下表还是从左到右
print(s[5:2:-1]) # 先大后小
print(s[::-1]) # 逆序输出

字符串常用方法

1、查找替换

• find()

str.find(*sub*[, *start*[, *end*]])

返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引。 可选参数 start 与 end 会被解读为切片表示法。 如果 sub 未被找到则返回 -1。

注解：

*find()*方法应该只在你需要知道 sub 所在位置时使用。 要检查 sub 是否为子字符串，请使用 in操作符:

• index()

str.index(*sub*[, *start*[, *end*]])

类似于 find()，但在找不到子类时会引发ValueError。

• rfind()

str.rfind(*sub*[, *start*[, *end*]])

返回子字符串 sub 在字符串内被找到的最大（最右）索引，这样 sub 将包含在 s[start:end] 当中。 可选参数 start 与 end 会被解读为切片表示法。 如果未找到则返回 -1。

是从右向左找

• rindex()

str.rindex(*sub*[, *start*[, *end*]])

类似于 rfind()，但在子字符串 sub 未找到时会引发ValueError。

• replace()

str.replace(*old*, *new*[, *count*])

返回字符串的副本，其中出现的所有子字符串 old 都将被替换为 new。 如果给出了可选参数 count，则只替换前 count 次出现。

替换时，默认替换所有符合的子串

• count()

str.count(*sub*[, *start*[, *end*]])

返回子字符串 sub 在 [start, end] 范围内非重叠出现的次数。 可选参数 start 与 end 会被解读为切片表示法。

2、分割连接

• split()

str.split(*sep=None*, *maxsplit=-1*)

返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分（因此，列表最多会有 maxsplit+1 个元素）。 如果 maxsplit 未指定或为 -1，则不限制拆分次数（进行所有可能的拆分）。

如果给出了 sep，则连续的分隔符不会被组合在一起而是被视为分隔空字符串 (例如 '1,,2'.split(',') 将返回 ['1', '', '2'])。 sep 参数可能由多个字符组成 (例如 '1<>2<>3'.split('<>') 将返回 ['1', '2', '3'])。 使用指定的分隔符拆分空字符串将返回 ['']。

如果 sep 未指定或为 None，则会应用另一种拆分算法：连续的空格会被视为单个分隔符，其结果将不包含开头或末尾的空字符串，如果字符串包含前缀或后缀空格的话。 因此，使用 None 拆分空字符串或仅包含空格的字符串将返回 []。

• splitlines()

str.splitlines([*keepends*])

返回由原字符串中各行组成的列表，在行边界的位置拆分。 结果列表中不包含行边界，除非给出了 keepends 且为真值。

此方法会以下列行边界进行拆分。 特别地，行边界是 universal newlines 的一个超集。

表示符	描述
\n	换行
\r	回车
\r\n	回车 + 换行
\v 或 \x0b	行制表符
\f 或 \x0c	换表单
\x1c	文件分隔符
\x1d	组分隔符
\x1e	记录分隔符
\x85	下一行 (C1 控制码)
\u2028	行分隔符
\u2029	段分隔符

• partition()

str.partition(*sep*)

在 sep 首次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含字符本身以及两个空字符串。

• rpatririon()

str.rpartition(*sep*)

在 sep 最后一次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含两个空字符串以及字符串本身。

• join()

str.join(*iterable*)

返回一个由 iterable 中的字符串拼接而成的字符串。 如果 iterable 中存在任何非字符串值包括 bytes 对象则会引发 TypeError。 调用该方法的字符串将作为元素之间的分隔。

3.判断

• startswith()

str.startswith(*prefix*[, *start*[, *end*]])

如果字符串以指定的 prefix 开始则返回 True，否则返回 False。 prefix 也可以为由多个供查找的前缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。

• endswith()

str.endswith(*suffix*[, *start*[, *end*]])

如果字符串以指定的 suffix 结束返回 True，否则返回 False。 suffix 也可以为由多个供查找的后缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。

• isalpha()

str.isalpha()

如果字符串中的所有字符都是字母，并且至少有一个字符，返回 True ，否则返回 False 。字母字符是指那些在 Unicode 字符数据库中定义为 “Letter” 的字符，即那些具有 “Lm”、“Lt”、“Lu”、“Ll” 或 “Lo” 之一的通用类别属性的字符。 注意，这与 Unicode 标准中定义的"字母"属性不同。

• isdigit()

str.isdigit()

如果字符串中的所有字符都是数字，并且至少有一个字符，返回 True ，否则返回 False 。 数字包括十进制字符和需要特殊处理的数字，如兼容性上标数字。这包括了不能用来组成十进制数的数字，如 Kharosthi 数。 严格地讲，数字是指属性值为 Numeric_Type=Digit 或 Numeric_Type=Decimal 的字符

• isalnum()

str.isalnum()

如果字符串中的所有字符都是字母或数字且至少有一个字符，则返回 True ， 否则返回 False 。 如果 c.isalpha() ， c.isdecimal() ， c.isdigit() ，或 c.isnumeric() 之中有一个返回 True ，则字符c是字母或数字。

• islower()

str.islower()

如果字符串中至少有一个区分大小写的字符且此类字符均为小写则返回 True ，否则返回 False 。

• isupper()

str.isupper()

如果字符串中至少有一个区分大小写的字符且此类字符均为大写则返回 True ，否则返回 False 。

4.转换

• upper()

str.upper()

返回原字符串的副本，其中所有区分大小写的字符均转换为大写。 请注意如果 s 包含不区分大小写的字符或者如果结果字符的 Unicode 类别不是 “Lu” (Letter, uppercase) 而是 “Lt” (Letter, titlecase) 则 s.upper().isupper() 有可能为 False。

• lower()

str.lower()

返回原字符串的副本，其所有区分大小写的字符均转换为小写。

• title()

str.title()

返回原字符串的标题版本，其中每个单词第一个字母为大写，其余字母为小写。

• capitalize()

str.capitalize()

返回原字符串的副本，其首个字符大写，其余为小写。 在 3.8 版更改: 第一个字符现在被放入了 titlecase 而不是 uppercase。 这意味着复合字母类字符将只有首个字母改为大写，而再不是全部字符大写。

5.对齐

• center()

str.center(width[, fillchar])

返回长度为 width 的字符串，原字符串居中。 使用指定的 fillchar 填充两边的空位（默认使用 ASCII 空格符）。 如果 width 小于等于 len(s) 则返回原字符串的副本。

• rjust()

str.rjust(width[, fillchar])

返回长度为 width 的字符串，原字符串在其中靠右对齐。 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。

• ljust()

str.ljust(width[, fillchar])

返回长度为 width 的字符串，原字符串在其中靠左对齐。 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。

6.去除空白

• strip()

str.strip([chars])

返回原字符串的副本，移除其中的前导和末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空白符。 实际上 chars 参数并非指定单个前缀或后缀；而是会移除参数值的所有组合

• lstrip()

str.lstrip([chars])

返回原字符串的副本，移除其中的前导字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空白符。 实际上 chars 参数并非指定单个前缀；而是会移除参数值的所有组合

• rstrip()

str.rstrip([chars])

返回原字符串的副本，移除其中的末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空白符。 实际上 chars 参数并非指定单个后缀；而是会移除参数值的所有组合

bool 布尔类型

True

False

tuple 元组

python的元组与列表相似，不同的是元组的元素不能修改。元组使用小括号，列表使用方括号。

可以存放不同的数据类型

 # 定义具有一个元素的元组
t = (1, )  # 一定要在元素后加上一个逗号

方法

• count()

• index()

可变数据类型

list列表

排序和倒序

• sort()

没有返回值

sort(*, key=None, reverse=False)

reverse 为一个布尔值。 如果设为 True，则每个列表元素将按反向顺序比较进行排序。

此方法会对列表进行原地排序，只使用 < 来进行各项间比较。 异常不会被屏蔽 —— 如果有任何比较操作失败，整个排序操作将失败（而列表可能会处于被部分修改的状态）。

"""
	sort和lambda函数使用
"""
ls = [{
   'id': '1', 'name': 'Tom', 'age': '11'}, {
   'id': '3', 'name': 'Sam', 'age': '33'}, {
   'id': '2', 'name': 'Rosy', 'age': '122'}]
print(ls)
ls.sort(key=lambda x: x['id'], reverse=False)
print(ls)

• reverse()

列表.reverse() 逆序排列

增加数据

• append()

• extent()

只能扩展一层

• insert()

插入数据时，如果指定下标超过下标范围，则在最后追加元素

列表查找

• index()

• count()

• in

• not in

列表删除

• pop()
• remove()
• del
• clear()

列表推导式

轻量级循环创建列表

格式：列表变量 = [表达式 for 变量 in range(10)]

# 基本使用
ls = [i for i in range(10)] # 0 ~ 9 的列表
print(ls)

ls = [(i, i + 1) for  i in range(10)] # 创建一个列表，列表里每个元素都是含有两个元素的元组
print(ls) # [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8), (8, 9), (9, 10)]

# 在循环过程中使用if
ls = [i for i in range(1, 10) if i % 2 == 0] # 1 ~ 10 内的偶数
print(ls)