- 1.注释
- 2.变量——存储数据
- 4.运算符
- 5.输入与输出
- 6.流程控制语句
- 7.函数
- 8.类
- 9.文件
1.注释
#我是一行单行注释 ''' 多行注释 注释一般在代码上行写， 有的时候会将当行注释写在代码后面 '''
2.变量——存储数据
1）变量的类型
1.number（数值）
int
float （没有double）
complex
2.boolean（布尔）
True #注意不要写成小写，true不存在
False
3.string（字符串）
用引号括起来，可以是单引号，也可以是双引号
注意： 在用单引号括起的字符串中若有撇号，则会出错，python会将第一个单引号和撇号之间的内容视为一个字符串。
#就近匹配 "'...'" # √ '"..."' # √ ""..."" #× ''...'' #×
操作：
s1+s2 #使用+来拼接字符串 len(s) #获取长度 s.split(参数) #通过参数内容切割字符串，返回列表 ''' 修改字符串大小，注意只是返回的字符串大小改变 ''' s.title() #以首字母大写的方式显示每个单词，即将每个单词的首字母都改为大写。 s.upper() #返回纯大写的字符串 s.lower() #返回纯小写的字符串 ''' 删除空白，注意并不是永久删除，需要将结果存储到变量 空白：泛指任何非打印字符，eg空格、制表符t、换行符n ''' s.rstrip() #删除末尾的空白 s.lstrip() #删除开头的空白 s.strip() #同时删除开头和末尾的空白 s.find(subs) #查找指定的内容subs在字符串s中是否存在，如果存在就返回内容第一次出现在字符串中的索引值 s.startwith(subs) #判断字符串是否以subs开头，是返回True，否则返回False s.endwith(subs) #。。。结尾 s.count(subs) #返回subs出现的次数 s.replace(旧的字符串，新的字符串) #用新的字符串替代旧的字符串，如果指定了次数，则替换个数不会超过指定的数
4.list（列表）
用[ ]表示列表,列表是有序集合，有索引——列表名称[索引]。索引从0开始，为方便，Python提供了一种特殊语法，通过让索引指定为-1，可让Python返回列表最后一个元素，-2返回倒数第二个元素…
注意： 使用列表索引不要越界，当列表为空时list[-1]会出现错误
操作：
list————增删改查
增：
list.append(v) #在列表末尾添加元素v
insert(i,v) #在索引为i的元素前插入v，即v变成索引为i的元素
list1.extend(list2) #将list2的元素逐一添加到list1中
改：
list[i]=v #将索引为i的值修改为v
查:
list[i] #索引
#in,not in
if v in list: #存在返回True，否则返回false
print("存在")
if v not in list: #不存在返回True，否则返回false
print("不存在")
删：
del list[i] #删除索引为i的元素
list.pop() #删除最后一个元素,并返回元素的值
list.remove(v) #删除值为v的元素，多个的话删除第一个
len(list) #获悉列表的长度
'''
组织列表
'''
list.sort() #对列表进行从小到大的排序，
list.sort(reverse=True) #从大到小的顺序排列
sorted(list) #对列表进行临时排序，即列表顺序实际不变，只返回排序后列表
#要反序可以给sorted()传递参数reverse=True
list.reverse() #将列表反过来
5.tuple（元组）
列表非常适合用于存储运行期间可能变化的数据集，列表是可以修改的。但我们有时需要创建一系列不可修改的元素，元组可以满足这种需求。
元组是用圆括号()定义的，可以用索引访问元素，可遍历，不可以修改元素。只能修改元组变量的指向。
#元组若元素只有一个的话，需要在元素后面加一个逗号 print(type((1))) #type(数据)返回数据的类型 print(type((1,))) #输出：
切片
————对操作的对象截取其中一部分的操作。
字符串，列表，元组都可以进行切片操作
#以list为例 #创建切片 list[m,n,r] #返回列表从索引m到索引n（不包含），以r为步长截取的列表，省略r则为1 [m:] #返回包含从索引m到末尾的内容 [:,n] #返回包含从索引0到n（不包含）的内容 #遍历切片——和遍历列表一样 #复制列表——创建一个包含整个列表的切片 list_new=list[:] list_new=list #无效，list_new和new是指向同一个列表
6.dict（字典）
字典是一系列键值对，用{ }括起来，其中每个键都与一个值相关联，
键与值之间用冒号分隔，而键值对之间用逗号分隔。
操作
list————增删改查
查：
dict[key] #返回value 若不存在则发生异常
dict.get(key) #返回value，若不存在不会出现异常，返回None
if k in dict: #如果k存在就返回v
print(dict[k])
if k not in dict: #如果不存在，就添加一个
dict[k]=v
#修改不成就添加
改：
dict[k]=v
增：
dict[k]=v #不存在的k
删：
del dict[k]
del dict #整个字典都删除了，字典对象不存在
dict.clear() #清空字典，变成空字典{}
嵌套
#字典列表，列表的每一个元素都为字典
[{},{},{},....]
#在字典中存储列表，一个键有多个值时，可以用列表存储，对于值需要遍历得到
{key:[],....}
#在字典中存储字典
{key:{},....}
2）查看变量数据类型type（变量名）
注意：在python中只要定义一个变量，而且它有数据，那么它的类型就已经确定了，不需要我们主动说明，系统会自动判断。
实质：变量没有类型，数据才有类型
a=12 print(type(a)) a=2.3 print(type(a)) a='sad' print(type(a)) #输出：
3)类型转换
a、转换成整数
int(x)
x为字符串，字符串内容为数值（且不是浮点数值）‘1.23’转不了
x为浮点数，则返回整数部分
x为布尔类型，True则返回1，False则返回0
b、转化为浮点数
float(x)
字符串x内容为数值型
c、转化为字符串
str(x)
d、转化为布尔类型
bool(x)
x为数值型数据，非0的返回True，0返回False
x为字符串，当字符串不是空的，则返回True，否则False
x为列表，元组，字典，只要不为空，就返回True，否则返回False
#为False：
bool(0)
bool(0.0)
bool('')
bool("")
bool(())
bool([])
bool({})
4）命名规范
– 只能包含字母，数字，下划线。且以字母或下划开头
– 不能将Python关键字和函数名用作变量名
– 遵循简短+具有描述性
– 慎用小写字母l和大写字母O
– 变量名小写
什么是变量 有哪些变量 变量的操作
4.运算符
1）算术运算符
+、-、*、/、//（取整，整除）、%、**（幂）
''' 1.字符串有+,代表拼接 非字符串和字符串进行拼接时要将非字符数据str()转为字符串 事实上str()的参数也可以是字符串 2.字符串有* 代表“复制” ''' >>'wy'*3 wywywy
2）赋值运算符
python允许同时给多个变量赋值
a=b=10 a,b,c=1,2,3 #则a=1，b=2，c=3 print(a,b,c) #1,2,3
复合赋值运算符
+= 等
3)比较运算符
==、<=、>=、！=、<、>
4）逻辑运算符
and
or
not
性能优化:短路
5.输入与输出
1)输出
a、普通输出
print(…)
b、格式化输出
# %s 代表字符串 %d 代表数值
name,age='wy',20
print('name: %s, age: %d' % (name,age))
2）输入
input() #！！！！返回字符串类型
6.流程控制语句
1）条件（分支）
#1.if if 判断条件： 语句 #true则执行 #if-else if 判断条件: 语句 else: 语句 #if-else-if if 判断条件： 语句 elif 判断条件: 语句 else: 语句 ''' 注意：if-elif结构可以去掉else语句，有些情况下不使用else代码块 而使用elif代码块来处理特定的情形会更清晰，且每个代码块都仅在通过相应的测试才会执行， 可以防止引入无效甚至恶意的数据。 '''
2）循环
——遍历
(1)for循环
for 变量 in 要遍历的数据:
qquad 循环体
可遍历的数据：
1.字符串,元组
2.数字序列
#使用range()函数得到不超过区间的连续整数 range(m,n) #代表[m,n-1]区间 range(n) #代表range(0,n), range(m,n,r) #r代表步长。 #使用list()可以将range()的结果直接转换为列表 list(range(1,5)) #[1,2,3,4] #对数字列表的统计计算： max(list) min(list) sum(list)
3.遍历列表
for i in list: print(i) #通过下标 for in range(len(list)): print(list[i]) ''' 列表解析:将for循环和创建列表元素的代码和在一起 列表名=[创建列表元素 for循环] ''' #得到的列表sequence为[1,9] sequence=[value**2 for value in range(1,5,2)]
4.遍历字典
#dict,keys()返回键
for k in dict.keys():
print(k,dict[k])
#dict.values() 返回v，每个元素的v都输出，哪怕重复
for v in dict.values():
print(v)
#想要返回不重复的v值，可以用set函数
for v in set(dict.values()):
print(v)
for v,k in dict.items():
print(v,k)
#i是dict的元素，即一个键值对
for i in dict.items()
print(i)
#按顺序变量字典中的所有键
for key in sorted(字典名.keys())
print(i)
a={1:3,7:4}
for i in a.items():
print(i)
#输出
(1, 3)
(7, 4)
（2）while循环
quad for循环是一种遍历列表的有效方式，但是在for循环过程中，不便修改列表，否则将导致Python难以跟踪其中的元素。要在遍历列表的同时对其进行修改，可使用while循环。
while 条件测试:
...
in
not in
while v in list
remove(v)
有关循环：
1.使用break退出循环，使用continue跳过一次循环
2.避免无限循环，出现无限循环的运行可以通过Ctrl+C停止
3.技巧：使用标志。在要求很多条件都满足才继续运行的程序中，可定义一个变量，用于判断整个程序是否处于活动状态。这个变量被称为标志 ，充当了程序的交通信号灯。你可让程序在标志为True 时继续运行，并在任何事件导致标志的值为False 时让程序停止运行。这样，在while 语句中就只需检查一个条件——标志的当前值是否为True ，并将所有测试（是否发生了应将标志设置为False 的事件）都放在其他地方，从而让程序变得更为整洁。
7.函数
def 函数名(形参)：
qquad 函数体
函数调用时的参数传递
——函数调用：f(实参）。函数调用中的每个实参都关联到函数定义中的一个形参
1）位置参数
按位置顺序将实参关联到函数定义中对应的形参
2）关键词参数
关键字实参是传递给函数，名称-值对。在实参中直接将名称和值关联起来了。则无需考虑函数调用中实参的顺序。
函数名(参数名=值，…)
3）默认值
定义函数时，可以给参数一个默认值，调用函数时，提供实参，则使用指定值，否则使用默认值。
注意：
使用默认值时，在形参列表中必须先列出没有默认值的形参，再列出有默认值的，即有默认值的参数定义时放在最后
4）传递列表
可修改列表（循环修改的话用while方便，当然可以用for索引循环修改列表）。如果不想修改列表，可以传递列表的副本——切片（复制列表）
5）传递任意数量的实参
有时不知道函数需要接受多少个实参，Python允许函数从调用语句中收集任意数量的实参。
'''
1.在可接受任意数量的形参前面加一个*表示该参数变量是一个元组:适用于传递的是位置参数
2.两个*即**表示为一个字典：适用于传递的是关键词参数
'''
#*————元组
def f(name,*info):
print(name,info)
f('wy','男',20,'singer')
#输出
wy ('男', 20, 'singer')
#**————字典
def f(name,**info):
print(name,info)
f('wy',sex='男',age=20,work='singer')
#输出
wy {'sex': '男', 'age': 20, 'work': 'singer'}
注意：
1.结合使用位置参数和任意数量实参时，必须将接纳任意数量实参的形参放在函数定义的形参列表最后
2.位置参数不能放在关键词参数后面，哪怕对应了自己的顺序，所以一般不要将位置参数和关键词参数混着用，除非位置参数的位置都在关键词参数之前
函数返回值
return 返回值
函数的局部变量和全局变量
——局部变量：在函数内部定义的变量，在函数外部不能使用
如果您需要创建一个全局变量，但被卡在本地作用域内，则可以使用 global 关键字。
global 关键字使变量成为全局变量。
def myfunc(): global x x = 100 myfunc() print(x) #100
8.类
（1）定义，使用
class 类名(): #约定类名使用大驼峰
def __init__(self,参数1，参数2，...): #
self.属性1=参数1
self.属性2=参数2
....
def 函数(self): #表示类的行为
....
说明：
1）方法__init__() 是一个特殊的方法，每次根据类创建实例时Python都会自动调用。
该方法名称前后都有两个下划线，这是一个约定，旨在避免Python的默认方法与普通方法名称发生冲突。
2）所有函数的参数self必不可少，还必须位于其他参数的前面，该参数对应的实参是python自动传入的，我们不需要传它
是一个指向实例本身的引用，让实例可以访问类中的属性和方法，
3）类中使用属性变量的格式为 self.属性名
类外使用的格式为 实例/对象名.属性名
类外调用方法的格式为 实例名.函数名(实参)
反正类里用self，类外用实例名
4）创建多个实例，每个实例都是一个独立的空间
5）__init__方法的参数可以是任意数量参数
6）给属性指定默认值
类中的每个属性都需要初始值，要么通过参数给属性赋值，要么给属性一个默认值，如果给了默认值，则可以不用传入为了提高初始值的参数，当然也可以提供（与默认值不一样时）。
class User():
def __init__(self, fname, lname, **other):
self.fname = fname
self.lname = lname
self.a = {}
self.hobby = 'food'
for k, v in other.items():
self.a[k] = v
def describe(self):
print(self.fname + ' ' + self.lname)
print(self.a)
print(self.hobby)
def greet(self):
print('hello ' + self.fname)
user = User('roy', 'Wang', age=20, work='singer', sex='男')
user.describe()
user.greet()
#输出
roy Wang
{'age': 20, 'work': 'singer', 'sex': '男'}
food
hello roy
（2）继承
1）创建子类时，父类需包含在当前文件且位于子类前面 ，或者导入父类
2）定义子类时，必须在类名后的括号里指定父类的名称
3）子类的init函数的参数需要提供父类init所需的参数，并在函数体内用super调用父类的init函数
4）重写父类方法：对于父类的方法，只要它不符合子类模拟的实物的行为，都可对其进行重写。为此，可在子类中定义一个这样的方法，即它与要重写的父类方法同名。这样，Python将不会考虑这个父类方法，而只关注你在子类 中定义的相应方法。
（3）导入类
1）导入模块的类
from 文件名（模块名） import 类名
from 文件名 import 类名1，类名2，…
2）导入整个模块
import 模块名
要访问模块中的类，则需要使用符合. 模块名.类名
3）导入模块中的所有类
from 模块名 import *
不推荐使用该方法，导入的类名不清楚，容易引发名称问题
如果需要使用一个模块的多个类最好使用第二种方法，然后使用模块名.类名来操作类
虽然文件开头并没有列出用到的所有类，但你清楚地知道在程序的哪些地方使用了导入的模块；
你还避免了导入模块中的每个类可能引发的名称冲突。
4）标准库中的类
模块random中import randint，
randint(a,b)返回一个位于指定范围[a,b]内的一个整数
注意：
1）当一个类A需要使用另一个类B时，可以把它们放在一个模块，用import A，或者分成两个模块，A所在的模块导入B，主模块导入A
2）如果一个类与另一个类是继承关系时，放在一个模块的话，在主模块需要使用子类的话还要记得导入父类。所以有继承关系的类，可以将子类与父类放在不同模块，在子类的模块里导入父类，在主模块里就只要导入子类。
9.文件
（1）打开/创建文件
#打开/创建文件
file_object=open(文件路径，访问模式) # 返回文件对象
file_object.read() #一字节一字节地读，效率较低
file_object.readline() #一行一行读但是返回的是列表形式，列表的元素即为文件一行一行的内容
file_object.write()
#with open 的形式
# 读取整个文件
with open('pi_digits.txt') as file_object:
contents = file_object.read()
print(contents)
'''
1.with open 形式不需要调用close()将文件关闭，python会自动关
2.read函数读取整个文件的内容,相比于原始文件，会在末尾多一个空行。——因为read() 到达文件末尾时返回一个空字符串，而将这个空字符串显示出来时就是一个空行。要删除多出来的空行，可在print 语句中使用rstrip() ：
'''
with open('pi_digits.txt') as file_object:
contents = file_object.read()
print(contents.rstrip())
#逐行读取文件
filename = 'pi_digits.txt'
with open(filename) as file_object:
for line in file_object:
print(line)
#open函数返回的对象只在with代码块内有效
with open(filename) as file_object:
lines = file_object.readlines()
for line in lines:
print(line.rstrip())
（2）文件路径
1.当文件与当前程序文件在同一目录下，则只需要文件名即可，
2.相对路径：不在同一目录，但在该目录的子目录中，则可以使用相对路径（相对于当前运行的程序所在的目录）
3.绝对路径
#需要用\表示
with open('C:\Users\ann\Desktop\11.txt') as file_object:
contents=file_object.read()
print(contents)
（3）模式
open(文件路径，模式)
'w’表示以写入的方式打开文件；
---- open返回的文件对象名.write(写入的内容)
'r’表示以读取的方式打开文件；
'a’表示以追加
'r+'表示既可以读取又可以写入
'a+'表示可以读，可以追加
注意：
1）python只能将字符串写入文本文件，将数值数据存储到文本文件中， 必须使用str()函数将其转换为字符串格式
2）write不会在写入的文本末尾添加换行符，因此需要使用空格、制表符、空行等符号来设置输出格式
3）以w的模式写入文件，如果文件不存在，则会自动创建；如果已经存在，则会先清空再写入 如果不想之前的内容被覆盖，可以以追加的方式写入
（4）序列化
我们可以将字符串写入本地文件，但是不能是一个对象（列表，字典，自定义类对象等）
TypeError: write() argument must be str, not list,所以需要将对象进行序列化才能写入文件中，Python提供了JSON模块实现数据的序列化与反序列化。
quad
JSON(JavascriptObjectNotation，JS对象简谱) 是一种轻量级的数据交换库，JSON的本质是字符串
1.序列化：
将要存储的数据，先进行序列化，“去掉” 原本的数据类型，变成字符串，再写入文件
#dump和dumps
json.dumps(a) #将对象a转化为字符串
1.dumps()：
import json #先import模块json
with open('1.json','w') as file:
a=[1,2,5]
r=json.dumps(a)
print(r,type(r)) #[1, 2, 5]
file.write(r)
2.dump()
#json.dump()接受两个参数：要存储的数据，用于存储数据的文件对象
import json
with open('1.json','w') as file:
a=[1,2,5]
json.dump(a,file)
2.反序列化:
从文件中读出数据，进行反序列化，“恢复” 数据该有的类型
#loads，load
1.loads()
import json
with open('1.json') as file:
content=file.read()
print(content,' ',type(content))
content=json.loads(content)
print(content,' ',type(content))
#输出
[1, 2, 5]
[1, 2, 5]
2.load()
import json
with open('1.json') as file:
content=json.load(file)
print(content,' ',type(content))
#输出
[1, 2, 5]
