（一）程序设计基础
目录
1.标识符\变量
2.输出
3.输入
1、数值表达式
2、字符串表达式
3、变量表达式
4、列表、元组和字典表达式
5、函数调用表达式
6、算术、比较和逻辑运算表达式
补充：常见的类型转换及其用法
补充：一些常见的输入要求
4、运算符\赋值语句
（1）、算术运算符
（2）、赋值运算符
（3）、逻辑运算符
（4）、比较运算符
5、数据类型
（1）索引
（2）、切片
（3）、字符串的处理与操作
6、嵌套
1.单一嵌套
2.多维嵌套
了解程序的编纂基础，是入手一门编程语言的重要起点，编程语言，是为了实现某些目的而使用的一种工具，这种工具就像小时候玩的积木，有不同形状的，也有相同形状的，为了搭好一个完美的“作品”，我们要充分考虑每一块积木的形状，以更好的将它放置在合适的地方。
编写程序也是一般，python语言里有很多的自带函数以及库文件，也可以与多种资源实现交互，在面对一个需要解决的问题时，我们首先要有一个初步的关于该问题的解决方法，即给出一个流程图式的工作步骤，就像学习有机化学式有一道题是化工流程，大致的结构就和这个相差无几。然后通过选择合适的程序语言去堆砌，从而实现对目标问题的解决。
1.标识符\变量
在数学的方程中，有两个名词，分别叫做因变量和自变量，他们统称为变量，在编程中，也有相类似的一个定义，也称为变量，之所以称之为变量，是因为它的值可以跟随编程者的输入，以及程序的运行过程而进行变化，通常情况下，一个变量都有一个“代称”，就像方程y=ax+b一样，自变量的代称是x，因变量的代称是y，那么同理，也会有方程z=ay+b、e=ad+b·····诸如此类，变量的代称都是可以人为定义的。
我们在定义变量时，有时会使用一个字母，有时会使用一个字符串，那么，这里就涉及到了另一个知识点——标识符，换一句话就是，标识符就是变量的名字（代称）。在Python中，标识符的规则如下：
- 标识符由字母、数字、下划线组成，区分大小写；（如：a1、aa、a_a、Aa都是可以的，并且Aa和aa是不同的变量名）
- 第一个字符必须是字母或下划线；
- 不能以数字开头；（如：1a是无法识别的）
- 标识符不能使用 Python 的关键字和保留字，例如
if、while、for等； - 标识符应具有描述性，便于理解和维护。
前四条是标识符的定义法则，而第五条则是一个基于方便实用和理解的规则，没有强制性要求，一般在编写短的程序时，只需要单个字母命名就够用了，在某些较长的程序里，为了防止定义和调用的混乱，可以采用字符串定义，比如定义一个列表，我们可以定义为：lst、lst1、lst10086、lst114514、lst_student等，便于识别分辨。
在第四项里，提到的python的关键字和保留字，是应用于一些算法或者语句的特殊字符，例如在循环语句中使用到的“for”、“in”、“range“、“while”，判断语句中的“if”，以及“break”、“continue”、“True”、“False”等，均不能作为变量名使用。
2.输出
对于一个程序，可以没有输入的内容，但既然要解决问题，就一定要反馈给我们一个结果，也就是会输出一个内容，对于python的输出，我们通常采用print来实现
一般结构为：
print()括号里填入你想输出的内容，可以是字符串，也可以是变量，亦或者是表达式
#对于输出字符串，通常要加引号
print("字符串")
print("zifuchuan")
print("字符串zifuchuan")
print("字符串zifuchuan ,./.''[';;")
#如果输出变量，则直接在括号里输入变量名，输出结果是该变量目前的值
a=0
print(a)#输出0
#如果括号里是一个不带引号的表达式，那么该表达式会经过计算之后，输出计算结果
a=1
b=2
print(a+b)#输出3以上是一般直接采用的输出格式
对于某些题目，会要求一些特殊的格式，比如输出后换行，输出后不换行，一行输出，输出无空格等。
如果要求一行输出，那么我们会再上面的基础上采用“end=“””，即以“”结尾，而不换行，输出后不换行也同理。
a=0
b=0
print(a,end="")
print(b)#输出结果为00
扩展开来，end=“”，引号里可以加很多类型，包括字符串，如若为end=None，那么输出就要换行了，end=后面只能跟字符串类型或者“None”。
对于输出的空格处理，很多时候要用到一种格式化输出“format”，format不仅可以用于输出，也可用于程序中的一些格式化处理，这里不做过度赘述。
a=0
print("a={}".format(a))format的作用就是将引号中大括号位置填充format后面括号里的内容（按顺序一一对应，必须是一个变量）。
在有些题目中要求了输出的位数精度，如保留n位小数，那么format可以很好的解决这个问题
pi=3.1415926
print("圆周率={:.2f}".format(pi)){:.2f}，这里面的2f即为格式符，以为保留两位小数，依次类推保留八位小数即为{:.8f}
3.输入
在输入中，我们一般会采用input（）的形式去输入自己想向代码提供的数据
a=input()直接调用input输入的内容是以“字符串”类型存储在变量名里的，是无法进行算术运算的。
例如输入数字6，变量名里存储的知识一个字符6而不是数字6，如果想让他能够用于数学运算，则需要进行“类型转换”，一般情况下，我们常用的类型转换有"eval()"、"int()"、"str()"等。
类型转换通常是可以和input()进行嵌套的，用eval举例即为：
b=eval(input())此时，如果输入数字6，变量名里存入的就是一个数字6，可以用来进行数学运算。
在这里要着重强调一个问题：在书上以及日常的学习中，“eval()”我们学习过一种用于“类型转换”的工具——，这里需要注意，eval()并不是一个严格的数据类型转换方法。
而是一个函数，可以将（）里的字符串作为 一种代码识别并执行，并返回运行结果，比如：
a=eval(6)，6是一个数字，运行结果就是它本身，故a=eval(6)=6。
a = eval("'hello'")，将字符串'hello' 作为一个有效的 Python 表达式传入eval()函数中，注意，在eval处理字符串时一定是带引号的字符串，而不能是eval（“hello”）
以下是eval能处理的“有效的 Python 表达式”的举例：
1、数值表达式
包括整数、浮点数、复数、十六进制数等
# 整数
a = 10
# 浮点数
b = 3.14
# 复数
c = 3 + 4j
# 十六进制数
d = 0x10
2、字符串表达式
包括单引号、双引号、三引号括起来的字符串。
# 单引号字符串
s1 = 'hello'
# 双引号字符串
s2 = "world"
# 三引号字符串
s3 = '''Python is a high-level programming language.'''
3、变量表达式
可以包含字母、数字、下划线等，但不能以数字开头。
# 合法的变量名
x = 10
y = 'hello'
z = True
# 不合法的变量名
# 1x = 10 # 以数字开头
# x$y = 20 # 包含非法字符 $
4、列表、元组和字典表达式
包括方括号、圆括号、花括号括起来的序列类型表达式。
# 列表表达式
list1 = [1, 2, 3]
# 元组表达式
tuple1 = (4, 5, 6)
# 字典表达式
dict1 = {'a': 1, 'b': 2, 'c': 3}
5、函数调用表达式
包括函数名和参数列表。
# 调用内置函数 len()
len('hello')
# 调用自定义函数 foo()
def foo(x):
return x + 1
foo(10)
6、算术、比较和逻辑运算表达式
包括加减乘除、取余、幂次、等于、不等于、小于等于等运算符。
# 加、减、乘、除、取余
3 + 4 - 5 * 6 / 7 % 8
# 幂次运算
2 ** 3
# 等于、不等于、小于等于等比较运算符
x == y
x != y
x <= y
在一般情况下，初学者在编写程序的时候，常用a=eval(input())，读取输入的数据，其他的eval的多层次使用不要求熟练使用。
补充：常见的类型转换及其用法
- int(x)：int() 函数可以将一个字符串或数值转换为整型。
- float(x)：float() 函数可以将一个字符串或数值转换为浮点型。
- str(x)：str() 函数可以将一个对象转换为字符串。
- bool(x)：bool() 函数可以将一个对象转换为布尔型，如果x为False、None、0、""，则返回False，否则返回True。
- list(x)：list() 函数可以将一个序列（例如字符串、元组、列表等）转换为列表。
- tuple(x)：tuple() 函数可以将一个序列转换为元组。
- set(x)：set() 函数可以将一个序列转换为集合。
- dict(x)：dict() 函数可以将一个包含键/值对的元组列表转换为字典。
以上内容中，常用1/2/3，偶尔使用5/7/8，对于4/6仅供参考，不要求理解，在后文中会更加具体的讲解每一种数据类型的特点。
以下为具体的程序实例：
# 将字符串转换为整数
a = int("123")
print(a) # 输出结果为 123
# 将浮点数转换为整数
b = int(3.14)
print(b) # 输出结果为 3
# 将字符串转换为浮点数
a = float("3.14")
print(a) # 输出结果为 3.14
# 将整数转换为浮点数
b = float(10)
print(b) # 输出结果为 10.0
# 将整数转换为字符串
a = str(123)
print(a) # 输出结果为 "123"
# 将浮点数转换为字符串
b = str(3.14)
print(b) # 输出结果为 "3.14"
# 将非空字符串转换为 True
a = bool("hello")
print(a) # 输出结果为 True
# 将数值类型 0 转换为 False
b = bool(0)
print(b) # 输出结果为 False
# 将元组转换为列表
a = list((1, 2, 3))
print(a) # 输出结果为 [1, 2, 3]
# 将字符串转换为列表
b = list("hello")
print(b) # 输出结果为 ['h', 'e', 'l', 'l', 'o']
# 将列表转换为元组
a = tuple([1, 2, 3])
print(a) # 输出结果为 (1, 2, 3)
# 将字符串转换为元组
b = tuple("hello")
print(b) # 输出结果为 ('h', 'e', 'l', 'l', 'o')
# 将列表转换为集合
a = set([1, 2, 3])
print(a) # 输出结果为 {1, 2, 3}
# 将字符串转换为集合
b = set("hello")
print(b) # 输出结果为 {'h', 'l', 'o', 'e'}
# 将元组列表转换为字典
a = dict([('a', 1), ('b', 2), ('c', 3)])
print(a) # 输出结果为 {'a': 1, 'b': 2, 'c': 3}
# 将包含键/值对的字典转换为另一个字典
b = dict({'one': 1, 'two': 2})
print(b) # 输出结果为 {'one': 1, 'two': 2}
补充：一些常见的输入要求
1：输入~~~，以空格隔开
这种情况下我们一般使用split()函数来处理，表现形式为：
a,b = input().split()此时a，b的值是字符串类型，如果需要用于计算，还需要进行相应的类型转换
如果想要在输入的同时完成类型转换可以参考以下方法
a, b = map(float, input().split())
这里使用了 input() 函数接收用户输入，在接收到输入后，使用 .split() 方法将输入按照空格进行划分并返回一个包含两个元素的列表。然后，使用 map() 函数将这两个字符串类型的元素分别转换成浮点数类型，并使用 float 函数作为 map() 函数的第一个参数。最后，将两个转换后的浮点数类型的值依次赋值给变量 a 和 b。当然了，float也可以换成int、eval等。
2：输入~~~，以“，”隔开
这种情况下有两种处理方式
一种是像上文所用到的split()函数，也可以采用混合赋值，例如:
a,b=1,2
a,b = input().split(",")4、运算符\赋值语句
在数学里，我们可以经常使用运算符进行基础的数学运算，比如加减乘除，相对应的，在python中，也有一系列的运算符用于执行各种操作，大致可以分为以下几种：
- 算术运算符
- 赋值运算符
- 逻辑运算符
- 比较运算符
- 位运算符
（1）、算术运算符
| 加法：+ |
| 减法：- |
| 乘法：* |
| 除法：/ |
| 取余：% |
| 整除：// |
| 乘方：** |
python里的加减乘法与一般的数学运算一样，值得注意的是归属除法范畴的三个运算符。
注：在乘法运算中，乘号“*”不可以省略，9*a不能写成9a，a*a不能写成aa，4*a*b一定不能写成4ab或者4*ab！！
（没有累阶乘！！！）对于“+=”、“-=”，是一种累加/累减运算符，相似的还有“*=”累乘、“/=累除”，“//=”累整除。
将他们转换成表达式就是：
| a+=n | a=a+n |
| a-=n | a=a-n |
| a*=n或a**=n | a=a*n或a=a**n |
| a/=n或a//=n | a=a/n或a=a//n |
看完以上运算符，我们可能又会发现一个新问题，上面的表格里出现了“/”、“//”、“/=”和“//=”几种关于除法的运算符，那么有什么区别呢？
在python里：
“/”表示除法，返回的是浮点数，也就是带小数的格式，及时是整除也会有一位0占位。
“//”表示整除，及时运算结果有小数，也只会返回整数部分，例如：
print(6/3)
# 输出：2.0
print(6//3)
# 输出：2
print（8/3）
# 输出：2.666666666665
print(8//3)
# 输出：2在这里还有一种特殊的除法，称为“求余运算”，求余符号是“%”，也就是我们熟知的百分号，他的运算逻辑是将被除数除以除数然后剩下不够整除的一部分返回为结果，例如：
a=10%3
print(a)在这里，10对3求余，首先10对3求整除的话为商3余1，那么10%3的结果就是余数1。
因此，对于10和3来说，10//3=3,10/3=3.3333333333333335，10%3=1。
值得注意的是，在python中，算术运算符可以之间链接数字和变量，也可以链接两个变量，例如：
a=2
b=3
c=3*a
#c=6
d=6//b
#d=2
e=a*b
#e=6（2）、赋值运算符
在编程语言中，值得一提的是，在c语言、c++以及python中，“=”是一个赋值符号，意思是将“=”右边的内容赋给左边的内容。在这里，我就可以再谈谈Python的一个好处，在python里只要你写出了
pi=3.1415926形如这样“变量名=数据”的格式，那么你就定义了这个变量名，并且可以在之后的程序中调用它
而在c++中，你还需要:
int pi；
pi=3.1415926；如果在同一段程序中，对同一个变量名进行了多次赋值，则该变量名的值为最后一次赋值后的值，例如：
a=6
a=a+6此时，这个变量a的值就是12.
在程序中我们可以采用链式赋值的方式给多个变量赋予一个相同的值，例如：
a=b=c=6
#a、b、c的值均为6还有一种赋值方式，将数个变量名用逗号隔开，等号右侧是相对应的数个值（也可以是存储在列表内的一组值），python会自动一一对应赋值，例如：
a,b,c=1,2,3
a,b,c=[1,2,3]
#以上两种写法结果都是a=1,b=2,c=3值得注意的是，采用这种方法时，左侧的变量数量必须与右侧的元素数量相等，否则就会出错。
这种方法还有一个常见的用法，在后面的“字典”中比较常见。
a,b=1,2
a,b=b,a在上面这个代码中，分别给a,b赋予1,2的值，然后又将b,a的值赋给a,b，这就成功完成了一次数值的交换，交换了a,b两个变量的值。
还有一些其他的用法，这里不做过多的赘述，因为在初学阶段并不常用。
（3）、逻辑运算符
计算机不仅可以进行数学运算也可以进行逻辑运算，什么是逻辑运算呢，逻辑运算有三个运算符，其名称及用法分别为：
| 与：and 当两个操作数都为True时，返回True；否则返回False。 |
或：or 当两个操作数至少有一个为True时，返回True；否则返回False。 示例： |
非：not 对操作数取反，如果原本为True，则返回False，否则返回True。 |
用代码表示即为：
a = True
b = False
c = a and b # 返回False
a = True
b = False
c = a or b # 返回True
a = True
b = not a # 返回False
值得注意的是，如同加减乘除具有优先级顺序，逻辑运算也具有优先级顺序，其优先顺序是not > and > or，即not运算符的优先级最高，其次是and运算符，最后是or运算符。如果需要改变运算顺序，可以使用圆括号来明确运算顺序，与算术运算相同。
（4）、比较运算符
对于“==”、“<=”、">="、"!="则为一种比较运算符，相对应在数学运算中：
| == | = |
| <= | < |
| >= | > |
| != |  |
（5）逻辑运算符（仅供介绍）
5、数据类型
在python中，有以下几种数据类型
- 数值型（又可分为包括整型、浮点型和复数型）
- 字符串型
- 布尔型
- 列表
- 元组
- 集合
- 字典
在这一部分我们着重讨论前两种，第三种属于逻辑运算不强调要求掌握，后四种，在介绍完基本控制结构后再详细讲述。
| 数值型（Numeric） 包括整数、浮点数和复数，这三种类型之间可以进行基本的算术运算。例如：
|
| 字符串型（String） 表示一串字符，可以使用单引号、双引号或三引号来表示。字符串也支持多种常用操作，例如索引、切片、连接、重复等。例如：
|
在python中，要进行一些计算时，通常要求进行运算的对象是相同的数据类型，比如：字符串型和数值型不能同时计算。上文中我们讲到过“类型转换”，指的就是将数据类型进行转换。
以下，笔者将着重讲解字符串这种数据类型的一些特点。
在上面的表格中写到：字符串表示一串字符，可以使用单引号、双引号或三引号来表示。
字符串这种数据类型，相较于数值型有一些很独特的特性，与后文中讲到的另外四种数据类型很相似。
字符串可以进行索引、切片、函数处理等
（1）索引
字符串的索引指的是通过编号访问字符串中单个字符的位置。字符串中每个字符都有一个唯一编号，从0开始，依次递增。可以使用方括号[]符号加上对应索引号来访问字符串中的某个字符。
就如同一群人在排队，从队首到队尾可以依次排号，一般的队列标号是从1开始，而对字符串的标号，则从0开始，例如：
a="sevfsafV"
print(a[0])
#输出s
可知，在字符串中，字符的编号和位置是相差一的，也就是，例如：第1个字符，编号为0，第5个字符，编号为4。
除了可以从开头向结尾编号索引，字符串还可以逆向索引，即从结尾向前索引，但是与正向索引不同的是，逆向索引从“-1开始编号”，也就是一个字符串的最后一个字符，编号为“-1”，倒数第二个字符，编号为“-2”
例如：字符串“hello”
| 正向 | 0 | 1 | 2 | 3 | 4 |
| 字符串 | h | e | l | l | o |
| 逆向 | -5 | -4 | -3 | -2 | -1 |
值得一提的是，字符串类型是包括字母，符号数字，以及空格，例如：“hello world”，这个字符串的长度是5+1+5=11，编号就是从0到10，逆向就是从-1到-11。再比如“afwa_..acewf wecf .”这个字符串既有字母、数字、符号，也有空格，长度为19.
（2）、切片
切片也是索引访问字符串中元素的一种方式，具体来讲，就是给一个起点，一个终点，返回中间的内容，切片的语法形式为 [起始索引:结束索引:步长]，具体的法则如下：
- 起始索引：表示要切片的起始位置，默认为 0。
- 结束索引：表示要切片的结束位置，但不包括该位置的字符。如果不设置，则默认到字符串的末尾。
- 步长：表示选取步长，如果不设置，默认为 1。
做一个解释，步长，也就是返回字符时的间隔，比如hello这个字符，按照[0:5:2]的方式，那么就是从h开始，到o结束，间隔为2，那么就返回h、l、o，跳过了e、l。
举例如下：
my_string = "Hello, World!"
# 获取从索引 0 开始到索引 4 的子串
print(my_string[0:5]) # 输出 "Hello"
# 获取从索引 7 开始到字符串结尾的子串
print(my_string[7:]) # 输出 "World!"
# 获取整个字符串
print(my_string[:]) # 输出 "Hello, World!"
# 每隔一个字符取一个字符
print(my_string[::2]) # 输出 "Hlo ol!"
# 反转字符串
print(my_string[::-1]) # 输出 "!dlroW ,olleH"
# 省略起始索引，表示从开头开始
print(my_string[:3]) # 输出 "Hel"
# 使用负数索引，表示从后往前数
print(my_string[-3:-1]) # 输出 "rl"
当你输入的起始位置或者结束位置超出该字符串的边界值时，会有以下三种情况：
- 起始索引超出边界，返回空字符串
- 结束索引超出边界，返回字符串结尾
- 步长为 0 或者负数，会抛出异常
my_string = "Hello"
# 起始索引超出边界，返回空字符串
print(my_string[10:]) # 输出 ""
# 结束索引超出边界，返回字符串结尾
print(my_string[2:10]) # 输出 "llo"
# 步长为 0 或者负数，会抛出异常
print(my_string[::0]) # 抛出 ValueError
（3）、字符串的处理与操作
在python中，字符串之间有一些类似于数值型的处理方法。
对于字符串也有一些运算符和函数，可以用来进行对字符串的不同目的的处理。
首先是我们讲一讲一些内置的字符串运算符：
python解释器提供了基本的字符串运算符，这里我们介绍三个主要的运算符：“+”、“*”、“in”等
- 字符串拼接
“+”：用于将两个字符串连接成一个新的字符串。 - 重复字符串
“*”：用于将一个字符串重复多次。 “in”和“not in”：用于判断一个字符串是否包含于另一个字符串中。
具体应用如下：
str1 = 'Hello'
str2 = 'World'
str3 = str1 + ', ' + str2 + '!'
print(str3) # 输出 "Hello, World!"
str1 = 'Python'
str2 = str1 * 3
print(str2) # 输出 "PythonPythonPython"
str1 = 'Hello, World!'
print('World' in str1) # 输出 True
print('world' not in str1) # 输出 True
然后我们再来介绍一些常用的处理字符串的内置函数：
-
len()：用于获取字符串的长度。 -
str()：将其他类型的数据转换为字符串类型。 -
max()：用于返回序列中最大的元素。 -
min()：用于返回序列中最小的元素。
str1 = 'hello'
print(len(str1)) # 输出 5
print(str(123)) # 输出 "123"
print(max(str1)) # 输出 "o"
print(min(str1)) # 输出 "e"在python中，还有更多的内置字符串处理方法，可以分为七个种类，在我们处理一些数据是提供了很大的便利，不是重点。
我另外开辟了一个小文章来展现这部分内容：python的内置的字符串处理方法
在前文中的“输入”部分中，我们提到了函数format的使用。python中“format”的一些基础使用方法
6、嵌套
什么是嵌套呢？
在编程中，嵌套是指在一个语句块中使用另外一个完整的语句块。具体来说，就是在一个代码块中再写入一个代码块。
在Python中，我们可以在下文中所讲到的很多结构中使用嵌套解决更为复杂的问题。
嵌套的语法结构比较简单，在Python中通过缩进来表示。
嵌套可以分为单一嵌套、多维嵌套等。
1.单一嵌套
单一嵌套是指将一个数据结构作为另一个数据结构的元素。例如，可以将列表作为元组的一个元素，或者将元组作为字典的一个值。
# 列表作为元组的一个元素
tuple1 = (1, 2, [3, 4])
print(tuple1)
# 输出：(1, 2, [3, 4])
# 元组作为字典的一个值
dict1 = {"name": ("Tom", "Jerry"), "age": 20}
print(dict1)
# 输出： {'name': ('Tom', 'Jerry'), 'age': 20}
2.多维嵌套
多维嵌套是指在一个数据结构中使用多个同类型的数据结构进行嵌套。例如，可以将多个列表嵌套到一个大列表中，形成二维列表；或者将多个字典嵌套到一个大字典中，形成多层字典。
# 列表嵌套
list1 = [[1, 2], [3, 4]]
print(list1)
# 输出：[[1, 2], [3, 4]]
# 字典嵌套
dict2 = {"info": {"name": "Tom", "age": 20}}
print(dict2)
# 输出： {'info': {'name': 'Tom', 'age': 20}}