对象类型
整数1
小数（浮点数）1.1
字符串‘你好’
列表[1,3,'你好']
元组（1，2，‘你好’）
字典{ key:‘value’,1:'你好' }
数字对象
运算优先级
（越是下面的操作符，优先级越高）
type函数
变量
变量（也叫变量名）就是对象的名字
变量名规则
不能以数字开头
不能和关键词、内置函数同名
变量名区分大小写
1.变量重新指向新的对象
一个对象可以有多个变量名
数字变量自增赋值
2.变量 指向的对象 本身发生变化
前提是对象是可变数据类型（字典、元组、自定义的类实例对象等）
字符串
字符串处理
字符串的拼接、字符串里面关键信息的提取、格式的转换等等。
引号内为字符串类型：
三引号写多行内容
转义符
转义符 \n : 换行
字符串中有引号
字符串元素索引
字符串切片
切出其中 你好
切出的内容一直到字符串的结尾 ：
hello[2:] ，后面的索引 空着不写，表示到整个字符串的结束 。
从字符串的开头切片：
hello[:2]
获取字符串长度
内置函数len
函数
定义函数
调用函数
参数
参数也是变量，命名规则不同
调用有参数的函数时，需要传入对应个数的参数。
函数返回值
不需要返回结果（如print），即完成函数任务
需要返回函数结果，需要return+返回结果
执行了函数中的 return 语句，就会立即从函数中返回到调用的地方，该函数下面还有代码，也不会再执行了
print不是返回值（return才是）
返回值要显示在屏幕上需要打印
缺省值函数
score一般为60（及格分）
防止调用函数时反复输入60，因此在定义函数是直接对参数score赋值，在被赋值参函数后参数都需被赋值
调用函数是参数可以指定参数名（此时可以颠倒顺序）
变量有限范围
局部变量
局部变量即在函数内变量，不可在函数外使用
局部变量：ret
全局变量
在函数外被定义的变量
函数内部优先使用函数内变量
局部变量变为全局变量：global（在变量前加global即定义全局变量）
常用内置函数
列表、元组
字符(str)、列表(list)、元组(tuple)、字典(dict) 都是具有 序列 特性的。
序列类型：可切片、索引、内置函数用于序列计算、算数运算
内置函数用于序列计算：
算数运算：
列表
对象之间逗号隔开，每一个对象是一个元素（最后一个元素 就是 另外的一个列表对象 [7,8,9]）
索引列表中列表元素
改变列表内容
改变列表对象
列表中写表达式
列表元素整体替换（切片赋值）
合并两个列表
元组
元组可以存放任何类型数据但内容不能改变，但元组中列表可以变
元组切片同列表
元素是否在元组中
多变量同时赋值
对tuple/list中多变量同时赋值
函数返回值可以是列表/元组
字典
存放键对值数据
用花括号 {} 定义，键和值之间用 冒号 隔开，每个元素之间用 逗号 隔开。
值 可以是任何类型的 对象，包括 数字、字符串、列表、元组、字典、自定义类型 等
members = {'account1':13,'account2':12}字典添加、修改、删除
#定义一个空字典
members = {}
#添加元素
members['account1'] = 13
#继续添加元素
members['account2'] = 12
#修改值
members['account2'] = 12
###
赋值语句
key不存在-添加元素
key存在-重新赋值
###
var[key] = something
#删除一个元素pop
val = members.pop('account1')
>>>var=13
pop会返回删除键的值，del不会
del members['account1']判断字典是否存在某个key
a in var # 检查 a 是否在var 中存在，存在返回True，否则返回False
a not in var # 检查 a 是否不在var 中，存在返回 False，否则返回 True访问字典的所有元素
items方法:将字典 所有的 键值对元组 存入的 一个类似列表的对象
members = {
'account1' : 13 ,
'account2' : 12 ,
'account3' : 15 ,
}
for account,level in members.items():
print (f'account:{account}, level:{level}')
#用for 循环， account level 两个变量就依次对应其中的每个元组里面的 两个元素
>>>[('account1', 13), ('account2', 12), ('account3', 15)]得到所有的 key 和value 对象
members.keys()
['account1', 'account2', 'account3']
members.values()
[13, 12, 15]清空字典
clear
members.clear()字典合并
update
members = {
'account1' : 13 ,
'account2' : 12 ,
'account3' : 15 ,
}
another = {
'account4' : 13 ,
'account5' : 12 ,
}
members.update(another)得到字典元素的个数
内置函数 len
members = {
'account1' : 13 ,
'account2' : 12 ,
'account3' : 15 ,
}
print(len(members)) # 结果为3，表示字典中有3个元素判断语句
布尔对象bool
布尔对象只有两种取值： True 和 False
布尔表达式
运算结果是布尔对象的表达式，就是 布尔表达式。
是否相等
是否不相等
其他
条件组合
逻辑且、或、非
逻辑先‘且’再‘或’
逻辑‘非’
判断语句
if-else
elif即else if，也是if判断
条件嵌套
对象的方法
对象类型
整数类型对象
字符串类型对象
列表类型对象
元组类型的对象
每个对象都有自己的方法（可以看成对象拥有的函数），对象类型决定对象方法
字符串类型对象方法
count
find
split/splitlines
split方法指定用 | 作为源字符串str1的分割符,将这个三个字符串存入一个列表中返回
splitlines 方法是把字符串 按换行符 进行切割
jion
join 方法和 split方法正好相反
join 是将列表中的字符串元素 以某字符串为连接符， 连接 为一个字符串
strip/lstrip/strip
strip方法可以将 字符串前面和后面的空格删除，但是不会删除字符串中间的空格
lstrip（删左边空格）/rstrip（删右边空格）
replace
startswith/endswith
是否以参数指定的字符串 开头/结尾
isdigit
是否是数字字符
字符串的倒序
:: 表示切片字符串的从头到尾，也就是全部内容， 而 步长 为 -1 表示，颠倒过来取元素
列表类型对象方法
append
改变列表的内容，在后面添加一个元素
append 方法的返回值是 None，而不是新的列表对象
insert
指定位置插入一个元素
insert方法的返回值也是 None
pop
从列表 取出（元素的索引）并删除 一个元素
remove
删除元素的 值（不用指定索引）
reverse
将列表元素倒过来
reverse 方法的返回值也是 None
index
返回 参数对象 在列表 中的位置，也就是索引
sort
对列表进行排序
sort方法的返回值是None
格式化字符串
占位符 %s（格式化符号）
简单说 %s 位置填入的结果，就是调用str函数的返回值。
（str函数：将对应的 格式化对象 作为 参数传入）
提供一个元组，里面依次存放需要填入到 %s 位置的数据。
指定宽度和对齐
%10s 中的 10 就是指定了格式化结果至少10个字符
左边对齐，可以加一个 ```-```
占位符 %d 和 %f
%d 用在 格式化对象 是 整数
%f 用在 格式化对象 是 浮点数的情况
保留小数点后面2位数字，就可以加上 .2
%s也可以格式化整数、浮点数但是指定宽度补空格而不能是0
f-string 格式化
字符串模板前加f，占位符用{} ,里面直接放入对应的数据对象
指定宽度
左右对齐
箭头朝左就是左对齐，箭头朝右就是右对齐
小数点后位数
指定小数点后保留几位（.1f就表示小数点后面保留1位）
不足补零
对 数字 的不足补零：不足指定宽度的时候不是补空格，而是补数字0，可以像这样 {salary:08}
对 字符串 的不足补零：使用符号 < 或者 > 同时指定左右对齐方式
循环
反复的执行一段代码
while 循环
检查一个条件表达式，表达式计算结果为True 时， 就执行下面缩进的代码
如此反复，直到条件表达式计算结果为False时，结束 循环。
while死循环
for 循环
字符串、列表或者 元组中依次取出每个元素进行操作（序列sequence类型就可以）
循环n次
enumerate 函数
找出下面列表中年龄大于17岁的学员，打印出他们在列表中的索引
break 终止循环
while循环从while True:开始到 print(f'输入的命令是{command}')结束
print('程序结束')是循环外语句
函数中的 break 、 return、continue、pass
break 停止，不输出
就是当 i % 2 == 0时，执行break,相当于跳出循环体，停止循环
def func2():
for i in range(1,11):
if i % 2 == 0:
break
#到第一个符合条件的情况下就停止。不输出符合条件的语句，并停止。
print(i)
func2()
# 输出结果：1
return停止，且输出
就是当 i % 2 == 0时，输出 i 的值，并停止循环
def func3():
for i in range(1,11):
if i % 2 == 0:
return i
#符合第一个条件的语句，输出并停止。
t = func3()
print(t)
# 输出结果：2
continue
就是当 i % 2 == 0时（符合判断），不执行print(i)， 继续执行下一个循环。continue跳出for循环中的当次序号为i的运算继续for循环的i+1运算
判别条件后的执行。
def func():
for i in range(1,11):
if i % 2 == 0:
continue
#if判断后，跳过continue语句下的表达式。不输出print(i)
print(i)
func()
# 输出结果：1 3 5 7 9
pass
pass是空语句，是为了保持程序结构的完整性。
def func1():
for i in range(1,11):
if i % 2 == 0:
pass
#pass不做任何操作
print(i)
func1()
# 1输出结果： 1 2 3 4 5 6 7 8 9 10
列表推导式
把一个列表里面的每个元素经过简单的处理生成另一个列表的操作
循环嵌套
循环的嵌套，就是循环里面还有循环
文件读写
open函数
打开文件
open( file,mode='r',buffering=-1,encoding=None,errors=None,newline=None,
closefd=True,opener=None) 参数 file
file参数指定了要打开文件的路径。
可以是相对路径，比如 ‘log.txt’， 就是指当前工作目录下面的log.txt 文件
绝对路径，比如 ’d:\project\log\log.txt'，
参数 mode
r 只读文本模式打开，这是最常用的一种模式
w 只写文本模式打开
a 追加文本模式打开
参数 encoding
encoding='utf8'
模块和库
模块
一个代码文件（也就是一个.py文件），我们也叫它一个模块（Module）
导入模块save
import save
# 使用 模块save里面的 savetofile 函数
save.savetofile(memberlist, avgfee)
包
放模块文件的目录，Python中把他们称之为 包 (Package)
import stock.food.beef
# 注意导入的是 stock.food.beef，调用的时候一定要加上所有的包路径前缀
stock.food.beef.stockleft()
我们也可以使用from…import… 的方式，像这样
from stock.food.beef import stockleft
stockleft()库
库是个抽象的概念，只要 某个模块 或者 一组模块 ， 开发它们的目的 就是给 其它模块调用的，就可以称之为库。
内置类型 （built-in types） 和 内置函数 （built-in functions）
无须使用import导入，可以直接使用
内置类型有：int、float、str、list、tuple等
内置函数有： int，str，print，type，len 等
Python标准库
需要使用import导入
有 sys, os, time, datetime, json，random 等
sys.path
import sys
for path in sys.path:
print (path)
设置环境变量
临时
比如，在windows下面，我们可以用这样的命令添加
set PYTHONPATH=c:\myproject;c:\myproject\mylib那么解释器启动后， c:\myproject 和 c:\myproject\mylib 这两个目录就被添加到了sys.path里面。
永久
例子
python 模块文件名为 m1，放在目录 d:\project\libs\p1\p2 下面
import p1.p2.m1
#或者
#from p1.p2 import m1
set PYTHONPATH=d:\project\libs自己添加目录作为模块搜索路径
在代码中直接修改sys.path，使用 append 或者 insert方法，把目录直接添加到该列表中
安装其他的库
安装 requests库
pip install requests指定使用豆瓣作为安装包的下载网站
pip install requests -i https://pypi.douban.com/simple/#导入及使用
import requests
requests.get('http://www.baidu.com')Pycharm 如何寻找导入的模块？
调试程序
语句错误
逻辑错误
代码处理逻辑有问题
最有效的方法的就是去 调试程序
所谓调试程序就是：检查程序运行过程中的 一些关键步骤里面变量 ，看看是否正确。从而判断出是哪里代码的问题。
调试程序的方法
在关键代码处 设置断点（ 设置某些代码行位置，当 程序运行 到这些位置，就会暂停执行）
执行断点一行代码
自定义类
整数对象 的类型是 int
字符串对象 的类型是 str
列表对象 的类型是 list
元组对象 的类型是 tuple
字典对象 的类型是 dict
查看对象的类型
内置函数type
>>> type(12)
<class 'int'> # 整数类型自定义类
类名（BenzCar） 首字母大写
属性： brand、country
方法：pressHorn
class BenzCar:
brand = '奔驰' # 品牌属性
country = '德国' # 产地属性
@staticmethod
def pressHorn():
print('嘟嘟~~~~~~')得到类属性的值
print(BenzCar.brand) @staticmethod 的修饰，说明这是该类的一个 静态方法（不会涉及到类中的方法和属性的操作），非静态方法（会涉及使用属性）
执行该类的静态方法
BenzCar.pressHorn()类的实例
产生类的实例对象（在类名后面加上括号）
car1 = BenzCar()
type(car1)
<class '__main__.BenzCar'>
class BenzCar:
brand = '奔驰'
country = '德国'
@staticmethod
def pressHorn():
print('嘟嘟~~~~~~')
car1 = BenzCar()
print(car1.brand)
car1.pressHorn()具体实例：
人 就是 一个 类， 而 关羽、张飞 就是 人 这个类的 具体实例。
狗 也是 一个 类， 而 你们家的阿黄 和 隔壁家的旺财 就是狗 这个类的 具体实例
方法：就是人会干什么
实例属性和实例方法
类属性：是类的共同特征属性
类的实例属性：
比如颜色、发动机编号 是每一辆奔驰车 都不同的，每个实例独有的属性，称之为 类的实例属性
初始化方法 __init__ 里面定义实例属性
初始化方法 __init__ ，创建两个实例属性 color 和 engineSN
__init__ 是 创建好实例后 立即就要执行的方法，所以称之为初始化方法。
class BenzCar:
brand = '奔驰'
country = '德国'
@staticmethod
def pressHorn():
print('嘟嘟~~~~~~')
# 初始化方法, 注意前后各有两个下划线
def __init__(self):
self.color = 'red' # 颜色
self.engineSN = '837873398' # 发动机编号类的实例方法
类的 实例方法 不需要任何修饰
实例方法（__init__）就是为了修改实例属性，否则实例方法就应该是类方法（pressHorn）
class BenzCar:
brand = '奔驰'
country = '德国'
@staticmethod
def pressHorn():
print('嘟嘟~~~~~~')
def __init__(self,color,engineSN):
self.color = color # 颜色
self.engineSN = engineSN # 发动机编号修改实例属性：每辆车的颜色、发动机号都是不同的，我们应该作为参数传进去
#（self会自动传入，因此只需要传入color、engineSN）
car1 = BenzCar('白色','24503425527866')
car2 = BenzCar('黑色','34598423586877')
print(car1.color)
print(car2.color)
print(car1.engineSN)
print(car2.engineSN)class BenzCar:
brand = '奔驰'
country = '德国'
@staticmethod
def pressHorn():
print('嘟嘟~~~~~~')
def __init__(self,color,engineSN):
self.color = color # 颜色
self.engineSN = engineSN # 发动机编号
def changeColor(self,newColor):
self.color = newColor
car1 = BenzCar('白色','24503425527866')
car1.changeColor('黑色')
print (car1.color)实例属性名称 和 静态属性 重复
通过什么访问就得到什么属性
class Car:
brand = '奔驰'
name = 'Car'
def __init__(self):
# 可以通过实例访问到类属性
print(self.brand)
# 定义实例属性和类属性重名
self.name = 'benz car'
c1 = Car()
print(f'通过实例名访问name：{c1.name}')
print(f'通过类名 访问name：{Car.name}')
类之间的关系
继承关系
人(父类) 这个类型 和 亚洲人( 子类 或者 派生类) 这个类型
亚洲人 这个类 就 继承 了 人 这个类
子类会自动拥有父类的一切属性和方法，并且可以拥有自己的属性和方法
继承方法1
类名的后面的括号里写上父类的名字
class BenzCar:
brand = '奔驰'
country = '德国'
@staticmethod
def pressHorn():
print('嘟嘟~~~~~~')
def __init__(self,color,engineSN):
self.color = color # 颜色
self.engineSN = engineSN # 发动机编号
def changeColor(self,newColor):
self.color = newColor
class Benz2016(BenzCar):
price = 580000
model = 'Benz2016'
class Benz2018(BenzCar):
price = 880000
model = 'Benz2018' 子类创建自己的属性和方法
class Benz2018(BenzCar):
price = 880000
model = 'Benz2018'
def __init__(self,color,engineSN,weight):
# 先调用父类的初始化方法
BenzCar.__init__(self,color,engineSN)
self.weight = weight # 车的重量
self.oilweight = 0 # 油的重量
# 加油
def fillOil(self, oilAdded):
self.oilweight += oilAdded
self.weight += oilAdded
这里 子类 Benz2018 ，新增了两个 类属性
价格： price
型号： model
新增了两个实例属性
整车重量：weight
油的重量：oilweight调用父类方法特别注意，先把父类方法参数写上，再加上子类特有参数
def __init__(self,color,engineSN,weight):
# 先调用父类的初始化方法
BenzCar.__init__(self,color,engineSN)
self.weight = weight
self.oilweight = 0 如果子类没有初始化方法，会自动调用父类初始化方法
class Rect:
def __init__(self):
print('初始化 rect')
class Squre(Rect):
pass
s = Squre()
运行结果，会打印出 初始化 rect子类 有自己 的初始化方法，不会自动化调用父类的初始化方法
class Rect:
def __init__(self):
print('初始化 rect')
class Square(Rect):
def __init__(self):
print('初始化 square')
s = Squre()
运行结果只会打印 初始化 square 。
继承方法2
函数 super()，不需要加上 self 参数
def __init__(self,color,engineSN,weight):
# 同样是调用父类的初始化方法
super().__init__(color, engineSN)
self.weight = weight
self.oilweight = 0 class Fruit():
def __init__(self, color, shape):
self.color = color
self.shape = shape
class Apple(Fruit):
def __init__(self, color, shape, taste):
Fruit.__init__(self, color, shape) # 等价于super().__init__(color, shape)
self.taste = taste
def feature(self):
print("Apple's color is {}, shape is {} and taste {}".format(
self.color, self.shape, self.taste))
class Orange(Fruit):
def __init__(self, color, shape, taste):
Fruit.__init__(self, color, shape)
self.taste = taste
def feature(self):
print("Orange's color is {}, shape is {} and taste {}".format(
self.color, self.shape, self.taste))
apple = Apple("red", "square", "sour")
orange = Orange("orange", "round", "sweet")
apple.feature()
orange.feature()
# 输出
# Apple's color is red, shape is square and taste sour
# Orange's color is orange, shape is round and taste sweet类的组合关系
再学函数
局部变量和全局变量
var = '桌子'
def test():
var = '椅子'
print(f"在函数中，var的值是：{var}")
test()
print(f"在函数外，var的值是：{var}")
在函数中，var的值是：椅子
在函数外，var的值是：桌子var = '桌子'
def test():
global var
var = '椅子'
print(f"在函数中，var的值是：{var}")
test()
print(f"在函数外，var的值是：{var}")
在函数中，var的值是：椅子
在函数外，var的值是：椅子可变参数
studentInfo = {
'张飞' : 18,
'赵云' : 17,
'许褚' : 16,
'典韦' : 18,
'关羽' : 19,
}
def printAge(students) :
for student in students:
print( f'学生：{student} , 年龄 {studentInfo[student]}')
printAge(['张飞', '典韦', '关羽'])
printAge(['赵云'])前面有一个星号 的 参数变量 students 是一个元组
在调用该函数的时候，Python解释器会创建一个 tuple 赋值给这个参数变量。并且会把 传入的数据对象 放到这个tuple对象里面
def printAge(*students) :
for student in students:
print( f'学生：{student} , 年龄 {studentInfo[student]}')
#调用函数
printAge('张飞', '典韦', '关羽')
printAge('赵云')参数展开printAge(*onebatch)
要传入的参数恰好已经在一个list（或者tuple） 中，在调用函数的时候,传入参数前面加上星号
onebatch = ['张飞', '典韦', '关羽']
#调用printAge
printAge (onebatch[0], onebatch[1], onebatch[2])
#或者printAge(*onebatch)关键字可变参数
前面有两个星号 的 参数变量 students 的值是一个字典
在调用该函数的时候，Python解释器会创建一个 dict （字典） 赋值给这个参数变量
def addStudents(table,**students):
print(type(students))
for name,age in students.items():
table[name] = age
table1 = {}
table2 = {}
addStudents(table1, 李白=20, 杜甫=24)
addStudents(table2, Jodan=45, James=32, onil=40)
print(table1)
print('----------------')
print(table2)
运行一下，输出结果如下
<class 'dict'>
<class 'dict'>
{'李白': 20, '杜甫': 24}
----------------
{'Jodan': 45, 'James': 32, 'onil': 40}要传入的参数恰好已经在一个dict） 中，在调用函数的时候,传入参数前面加上两个星号
onebatch = {'李白': 20, '杜甫': 24}
addStudents(table1, **onebatch)numpy/pandas
可以简单理解
numpy是列表，整个数据是矩阵
pandas是字典，可以对每一行每一列命名（dataframe）
二维数组又称为矩阵，行列数相等的矩阵称为方阵
range()和np.arange()区别
range()是python自带函数
np.arange()：
# 一个参数 默认起点0，步长为1 输出：[0 1 2 3 4 5]
a = np.arange(5)
# 两个参数 默认步长为1 输出[3 4 5]
a = np.arange(3,6)
# 三个参数 起点为0，终点为3，步长为0.5 输出[ 0. 0.5 1. 1.5 2. 2.5]
a = np.arange(0, 3, 0.5)区别：
返回类型不同： range返回object，np.arange()返回ndarray（n维数组即矩阵）
步长：ndarray步长可为小数， range不可
ndarray可用做向量
点乘和矩阵乘法
点乘a*b
矩阵乘法 np.dot()
运算法则为矩阵乘法
np.random
索引
在矩阵中可以直接索引
在dataframe中需要借助函数loc/iloc
数组组合
split
loc/iloc(pd库中)
axis=0/1的理解
axis是扫描方向
axis=1为横向移动，axis=0为纵向移动，而不是行和列
series序列
pandas中的一维数据结构，类似于python中的列表和Numpy中的Ndarray对象,在 Series 中包含的数据类型可以是整数，浮点数，字符串，python对象等。
# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = {'a' : 0., 'b' : 1., 'c' : 2.}
s = pd.Series(data)
print (s)
>>>
a 0.0
b 1.0
c 2.0
dtype: float64dataframe
选择dataframe中大于某一数值的数据，并输出其对应的行数和列数
import pandas as pd
df=pd.DataFrame([[60,20,36,78],[95,35,10,6],[68,63,82,30]],columns=['a','b','c','d'])
print('数据框中大于50的数:')
for i in df.index:
for j in df.columns:
if df.loc[i,j]>50:
print(f'{i}行{j}列，{df.loc[i,j]}')
扫一扫
1310
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
