第一节基本语法
1.打印语句：print(常量) 或者print（变量名）
2.注释符号：# 注释多行快捷键：ctrl+/
3.变量的类型:查看变量类型 print(type(变量名))
基本类型:
整型：int直接是数字
浮点型：float小数
字符串型:str 赋值的时候可以用双引号或单引号或三引号
布尔型:bool 只有两个值：True 或 False
特有类型：
元组：小括号
列表：中括号
字典：大括号-key value：键和值对应关系
4.变量的命名规则：
1) 只能包含字母、数字、下划线
2）不能包含空格
3）不要将关键字和函数名作为变量名
4）不要太长，有描述性
5）慎用小写字母l 大写字母O
5.运算符
加+ 减- 乘* 除/ 幂**
异或符号^
a=2 # a 0010b
b=3 # b 0011
b=a^b # b 0001
a=a^b # a 0011
b=a^b # b 0010
6.变量的类型转换
变量名=新类型名(变量名)
7.从键盘读入变量值
a=input("输入前打印内容")，从键盘读入值赋值给变量a, 注意：缺省类型为str型
8. 关系运算符：
== 等于 !=不等于 > 大于 < 小于 >=大于等于 <=小于等于
9.逻辑运算符：
and 且 ：两边的表达式都为真，值是真
or 或 ： 至少有一个表达式为真，值是真
not 非： 表达式如果为真，值是假
10 if 语句
1)
if (a>b):
print("a的值大于b")
2)
if (a>b):
print("a的值大于b")
else:
print("a的值不大于b")
3)
if (a>b):
print("a的值大于b")
elif (a==b):
print("a的值等于b"）
else:
print("a的值小于b")
4)
if (a>b):
print("a的值大于b")
else:
if (a<b):
print("a的值小于b")
else:
print("a的值等于b"）
第二节元组
1.元组的定义
（元素1，元素2，元素3）
元素可以是数字，也可以是字符串，也可以是变量名
2.元组的类型：tuple
3. 查看元组中元素的个数 ：len(元组变量名)
4.元组的索引，用[]表示 元素依次是[0] [1] ...[len(元组)-1]
5.range()函数
用法：range(起始值,终到值,步长值）
起始值如果省略默认值为0， 步长值为如果省略默认值为1 range(n)=range(0,n,1)
数值序列里不包含终到值
6.遍历打印元组元素的方法一：
for i in tp02:
print(i)
方法二：
for i in range(len(tp01)):
print(tp01[i])
7.元组的元素可以是元组,如果是二维元组，索引用[][]
8.元组的负索引
[-1]倒数第一个元素 依次类推
9.元组的切片
1）[:] 把所有元素都切出来
2）索引可以为正索引也可是为负索引， [索引1:索引2] 从索引1位置的元素开始切,切到索引2位置的元素且不包含索引2位置的元素
如果有交集，就是非空的元组，如果没有交集，就是空元组
第三节列表
1.列表的类型：list
2.列表的定义 []
3.列表的索引、切片跟元组一致
4.遍历打印列表中的元素
方法一：
for i in list01:
print(i)
方法二：
for i in range(len(list01)):
print(list01[i])
5.列表跟元组的区别：
元组生成后，元素的个数不能修改，元素的值不能修改
列表生成后，元素的个数可以修改，元素的值可以修改
6.列表的内置方法（函数）
1) list01[索引]=新的值
2）list01.append(元素值) 在列表末尾添加元素
3）list01.insert(索引,元素值） 在列表指定位置添加元素
4）list01.index(元素1) 查找元素1的索引值(列表中第一个元素1）
5）del list01[索引值] 删除指定位置的元素
6）list01.pop(索引值） 删除指定位置的元素，如果删除最后一个元素，括号可以为空
7）list01.remove(元素值) 删除列表中指定的元素值，如果有多个相同值，只删除最前面的元素
8）list01.sort() 永久性对列表中元素进行排序（升序）
9）sorted(list01) 临时对列表元素进行排序（升序）
10）list01.reverse() 永久性对列表元素的位置反转
11）len(list01) 列表的长度（元素的个数）
7.用if判断某个元素值是否在列表中
if 元素值 in list01:
print('。。。。。')
第四节while循环
1.求模运算符 % : 结果是两个数相除的余数
2.最简单的while循环
while (表达式）：
循环体内语句
3.当所有表达式都为真的时候，才执行循环体内语句
while (表达式一）and （表达式二）and（表达式三）
循环体内语句
4.当任一表达式为真的时候，就会执行循环体内语句
while (表达式一）or （表达式二）or（表达式三）
循环体内语句
5.break:立刻退出循环，循环中余下的代码不会执行
6.continue:退出本次循环，循环中余下的代码不会执行，返回到循环开头，根据条件判断是否执行下一次循环
7.当列表不为空的时候，执行循环内语句，当列表为空的时候，退出循环
While 列表:
循环体内语句
8.while 循环操作列表：
list01=["abc","dfdfasff","df","333333333333333"]
list02=[]
while list01:
a=list01.pop()
if (len(a)>6):
print("用户名 %s 不合法，验证未通过"%a)
else:
list02.append(a)
print("合法的用户名列表：",list02)
9.在列表中清除所有值为df的元素:
while "df" in list01:
list01.remove("df")
第五节字典
1.字典的类型名：dict
2.字典中所有的键 dict01.keys(),用列表显示
3.字典中所有的值 dict01.values(),用列表显示
4.引用字典中某个值，dict01[相应的键名]
5. dict01[键]=值 ， 如果字典中没有该键，则在字典中添加键-值对
如果字典中已有该键，则用新的值更新原来的键-值对
6. del dict01[键]， 在字典中删除键-值对
7. 遍历打印字典中的键
for i in dict01.keys():
print(i)
8.遍历打印字典中的值
for i in dict01.values():
print(i)
9.遍历打印字典中的键-值对
for i, j in dict01.items():
print(i,j)
for i in dict01.items():
print(i[0],i[1])
10. dict01.get(键) :引用字典中键对应的值，如果该键不在字典中，返回None
11. dict01.get(键，缺省值)：引用字典中键对应的值，如果该键不在字典中，返回缺省值
12. dict01.update(dict02) :用字典dict02去更新字典dict01
13. dict01.pop(键,缺省值):删除字典中的键-值对，返回键对应的值，如果字典中没有该键，返回缺省值
14, dict01.copy() :深拷贝一份字典
第六节函数
1.函数的定义
函数的名称 可以是字母、数字、下划线的组合，但是不能用数字开头
def 函数名(参数1，参数2，...)：
...
return 变量
2.形参：形式参数 定义函数的时候的参数名
3.实参：实际参数 调用函数的时候，向函数传递的参数名
4.局部变量：函数体内部赋值的变量
5.调用函数传递的参数也可以是 元组、列表、字典
6.定义函数的时候，形参可设定缺省值
def 函数名(参数1=缺省值，参数2=缺省值，...)：
...
7.传递可变数量的参数，参数1为所有参数生成的一个元组
def 函数名(*参数1)：
...
8.计算任意多个数字相加的总和
def f01(*tp01):
print("调用函数f01")
list01=list(tp01)
s=0
for i in range(len(list01)):
s=s+list01[i]
return s
9.嵌套函数的层数控制在3层以内
def sum(x,y):
print("调用sum函数")
return x+y
def sub(x,y):
print("调用sub函数")
return x-y
def f01(x,y):
print("调用f01函数")
print(sum(x,y))
print(sub(x,y))
f01(9,2)
10.模块：把一组相关联的函数写到一个文件中
11.从另外一个模块导入函数
import 模块名
调用语法： 模块名.函数名
from 模块名 import 函数1，函数2，... 或 from 模块名 import *
调用语法： 函数名
第七节字符串及时间
1.字符串的长度 len(字符串变量)
2.字符串的切片与元组和列表一样
3.在字符串中查找第一个子字符串的起始索引位置
str1.find(子字符串),如果没有找到，返回值是-1
4.在字符串中查找倒数第一个子字符串的起始索引位置
str1.rfind(子字符串),如果没有找到，返回值是-1
5. 在字符串中替换子字符 *临时的
str1.replace("原来的子串","新的子串")
6. 字符串中的转义符：
\n(换行） \t(横向制表符） \v(纵向制表符）\b(退格符）
7.去掉字符串中的转义符：*两端的符号，临时
str1.strip() :去掉字符串中的转义符
8.字符串的合并
str1+str2
9.日期转换字符串。自动化生成报告常用
print(time.strftime("%Y-%m-%d",time.localtime())
%Y:四位年份
%y;两位年份
%m:月份
%d:当月第几天
%H:小时数(0-23)
%M:分钟数(0-59)
%S:秒数(0-59)
第八节文件和目录操作
1.对操作系统中文件和目录的操作，需要导入模块os 和 os.path
2. os.getcwd()： 值为当前的工作目录
3. os.chdir("指定路径")： 改变工作目录为指定的路径
4. os.listdir():值为当面工作目录下的所有内容（下一级目录和文件）
os.listdir("指定路径"）:值为指定路径下的所有内容:下一级目录和文件
5. os.mkdir("目录名")，在当前工作目录下新建一个目录
os.mkdir("指定路径\\目录名") 在指定路径下新建一个目录
6. os.makedirs("多级目录") ,在当前工作目录下新建多级目录
os.makedirs("指定路径\\多级目录") 在指定路径下新建多级目录
7. os.rmdir("目录名")，在当前工作目录下删除一个空目录"
os.rmdir("指定路径\\目录名") 在指定路径下删除一个空目录
8. os.removedirs("多级目录") ,在当前工作目录下删除多级空目录
os.removedirs("指定路径\\多级目录") 在指定路径下删除多级空目录
9. os.path.isdir("指定路径")， 判断指定路径是否为目录，如果是返回True，否则返回False
os.path.isfile("指定路径")，判断指定路径是否为文件，如果是返回True，否则返回False
10. os.path.exists("指定路径"），判断指定路径是否存在，如果是返回True，否则返回False
11. 绝对路径: C:\\Windows\\System32\\cacls.exe
os.path.isabs("指定路径")，判断指定路径是否为绝对路径，如果是返回True，否则返回False
12. os.remove("指定路径下文件名"）， 删除指定路径下的一个文件
13. os.rename("原来的目录名或文件名","新的目录名或文件名")
第九节文件读写
1. 打开一个文件 ： f01=open("指定路径下文件名","打开模式")
关闭一个文件对象： f01.close()
打开模式： r 只读
w 写入 如果该文件里有内容，先删除文件内容，如果文件不存在，先新建文件
a 写入 在文件末尾新增内容，如果文件不存在，先新建文件
2. 读取文件的内置方法（函数）
1）f01.readline() : 读取文件中的一行，返回值为str型
打印文件内容：
f01=open("2.txt","r")
str1="1"
while (str1!=""):
str1=f01.readline()
print(str1)
f01.close()
2）f01.readlines():读取文件多行，返回值为列表，每一行的内容为列表中的一个元素
打印文件内容：
f01=open("2.txt","r")
list01=f01.readlines()
for i in list01:
print(i)
f01.close()
3）f01.read():读取文件所有内容，返回值为str型
打印文件内容：
f01=open("2.txt","r")
str1=f01.read()
print(str1)
f01.close()
4) f01.read(n):读取文件中前n个字节的内容，返回值为str型
f01.tell(): 值为操作文件的指针
3. 写入文件的内置方法（函数）
1）f01.write(字符串): 向文件中写入字符串
2）f01.writelines(列表）：向文件中写入列表中的元素（列表中的元素类型必须是str型）
4.文件的属性
f01.mode 文件的打开模式，返回值为str型
f01.closed 文件是否关闭，返回值为bool型
f01.name 文件的名字，返回值为str型
5.os 和os.path模块关于文件的常用内置方法
os.stat(文件名）：返回文件的所有属性
os.startfile(文件名）：启动操作系统关联程序打开文件
os.path.abspath（文件名): 返回文件的绝对路径，值为str型
os.path.getsize（文件名):返回文件的大小，值为int型
os.path.isabs(路径）：判断路径是否为绝对路径，值为bool型
os.path.isfile(文件名):判断文件是否为文件，值为bool型
第十节类基础
1.定义类的关键字：class
2.最简单的类：
class 类名():
def __init__(self):
print("类初始化")
对象名(变量）=类名()
3.类的初始化方法
def __init__(self,属性1,属性2):
self.属性1=属性1
self.属性2=属性2
4.用类生成对象
对象名=类名(属性1，属性2)
5.访问属性
对象名.属性1
对象名.属性2
...
6.调用方法
对象名.方法名
7.定义一个子类
class 子类名（父类名）
8. 子类的初始化__init__(self,属性1，属性2)
调用父类的初始化 super().__init__(属性1,属性2)
9. 子类可以在初始化的方法里新增自己的属性
10.子类可以重写父类里定义好的方法
11. 异常处理语句
try:
f01=open("44.dat","r")
print("异常出现后语句")
print(f01.read())
except 异常类名:
print("捕获异常")
except:
print("捕获到其他异常")
12, 常用的异常名
FileNotFoundError：文件未找到异常
TypeError :类型异常
NameError：名称异常
MemoryError:内存异常
ImportError：导入异常
AttributeError:属性引用和属性赋值异常
ZeroDivisionError:除0异常
OverflowError：溢出异常
FloatingPointError:浮点数操作异常
附加内容面试题
99乘法表：
list1=[]
for i in range(1,10):
for j in range(1,i+1):
print("%d*%d=%d"%(j,i,j*i),end="\t\t")
list1.append(j*i)
print()
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
for i in range(len(list1)):
for j in range(len(list1)-i-1):
if list1[j]>list1[j+1]:
list1[j] , list1[j +1]=list1[j+1] , list1[j]
它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，故名
8 6 5 9 1
冒泡排序算法的运作如下：（从后往前）
1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3.针对所有的元素重复以上的步骤，除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较
8 6 5 9 1
6 8 5 9 1
6 5 8 9 1
6 5 8 1 9
JAVA 冒泡排序：
public class BubbleSort
{
public void sort(int[] a)
{
int temp = 0;
for (int i = a.length - 1; i > 0; --i)
{
for (int j = 0; j < i; ++j)
{
if (a[j + 1] < a[j])
{
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}
}
作者：科研小田 https://www.bilibili.com/read/cv3884840 出处：bilibili
863
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
