找帮助文档 dir(方法) help(方法)
例如： dir(list) 找出列表的各种方法
Python变量相当于一个标签，贴那大哪 ，指哪打哪
输入： a=int(input(‘请输入一个整数:’))
输出：print(‘这个整数的值为’,a)
Python没有函数或者循环的边界括号，只根据缩进来识别那些代码是循环内的（即那些代码是循环体），
条件语句即if else 或者while 语句后面都要加入: 即冒号
Python变量不用定义，直接使用，更形象的说是一个标签
缩进很重要，并没有悬挂else的现象，同一缩进级别的就是绑定的
For循环， 与C不一样，Python的for循环可以自动的调用迭代器的next方法，并自动结束循环。很智能
for 目标 in 表达式：
循环体
列表 是 C语言的数组
定于 number=[1,2,3,4,5,5]
Len() 求长度
Range() 和 for 循环 是一对
Range(1:5) 生成1 到4 的序列 range(5) 生成0到4的序列
列表 是 C语言的数组
定于 number=[1,2,3,4,5,5] 列表里什么都可以放，同一列表中不同类型的数据也可以放 num=[‘123‘,123,4] 字符串 整数 对象 都可以往列表中扔
num=[] 空列表
向列表添加元素：
Append方法 num.append(‘zhang’) 传入字符串 ‘zhang’ 但是一次只能加入一个元素
Extend num.extend([‘zhang’,’li’]) 以列表的形式进行扩展 可添加多个
Insert（列表中的位置，插入的元素）
向列表中插入元素：
Remove(要移除的元素) 并不需要知道 要删除的元素存在哪个位置
Del 删除整个列表
Pop() 方法 取出最后一个元素， 并且将删除的元素返回
Pop(索引值) 删除索引值对应的元素
一次性获取多个列表元素：列表分片 或者切片
Num[1：3] 获取索引值从1到2的元素 得到原来列表的拷贝，原来列表并没有改变 num[:3] 获取从第一个开始位置（索引为0）到索引2的元素
num[2:] 获取从索引值为2到最后一个元素
num[:] 全部元素
其他操作：
10 in num 假若10 在num中 返回1 否则 返回0
10 not in num 假若10不在num中 返回1 否则返回0
Num*3 将num列表中的元素 复制成三批 假若num=[1,2,3] num*3 为
[1,2,3,1,2,3,1,2,3] 此时的* 变成了重复操作符
Num.count(123) 查找num中123 元素出现的次数 并返回
Num.index(123) 返回元素123 在列表中的位置 （默认是第一个出现的元素）
Num.index(123,3,7) 从三开始数 找123 的位置 一直到7
num.Reverse() 整个列表元素原地反转
Num.sort() 排序 默认从小到大排序 num.sort(reverse=true) 从大到小排列
print(‘this is %.4f‘ %2.12345)
this is 2.1235 格式输出
元祖 中的元素定义后就不能改变了，不能删除和插入元素 但可以更新元祖 这一点和列表不一样。
元祖创建时用小括号
Tuple1=(1,2,3,,4,5,6,7,8) 元祖tuple1 访问元素的方法和列表一样
一个元素的元祖的定义 tuple1=(1,) 或者tuple=1, 一定要有逗号 要不然就是整型了
Tupl1=1,
Tuple2=(‘zhang’,’li’,’wang’ ) 更新了元祖
如何在元祖中插入元素
Tuple1=(‘李宁’，‘阿迪达斯’，‘耐克’，‘安踏’)
加入361
Tuple1=tuple1[：2]+（‘361’，）+tuple2[2:] 拼接
合成 李宁 阿迪达斯 361 耐克 安踏
字符串： str
Str=’i love my school’
Str[2] 找出索引为2的元素 也就是 l
Python并没有字符的概念
str=str[：2]+（‘361’，）+str[2:] 拼接 列表的一些基本操作 字符串也可以用 切片、 比较操作符，逻辑操作符 成员操作符 In not in 都和列表是一样的
字符串格式化： format 函数 接收位置参数 和关键字参数
未知参数 ‘{0} love {1}.{2}‘.format(‘i‘,‘you‘,‘now‘) 花括号是必须的 花括号代表代替字段
‘i love you.now‘
关键字参数 ‘{a} love {b}.{c}‘.format(a=’i‘,b=‘you‘,c=‘now‘)
结果一样
‘{{0}}‘.format(‘你真牛逼‘) 输出 ‘{0}‘ 并不输出你真牛逼， 因为0已经被花括号包括，失去了之前的意义了、
格式化：
‘{0:.2f}{1}‘.format(2.345,‘结果‘) 其中{0:.2f} 冒号表示 格式化的开始 后面跟的就是格式化操作符。 点2表示 保留两位小数 f 就是浮点数
格式化字符串 和printF C语言 功能一样
‘%c‘ % 97 打出 ‘a’
print(‘%c‘ %97)
格式化整数：print(‘%d‘ %9.7) 输出 9
列表 元祖 字符串 都是可以索引的， 且都是从0开始索引的 都可以分片 可以有一些基本的操作符
序列：列表 元祖 字符串的统称
序列的常见的内置方法：
List() 把一个对象转化为list列表 对象
b=‘i love my school‘
b=list(b)
B=[‘i‘, ‘ ‘, ‘l‘, ‘o‘, ‘v‘, ‘e‘, ‘ ‘, ‘m‘, ‘y‘, ‘ ‘, ‘s‘, ‘c‘, ‘h‘, ‘o‘, ‘o‘, ‘l‘]
Tuple() 把一个可迭代对象转化为元祖
Len(a) 返回a的长度
Max(a) 返回参数a(序列或者元祖的最大值)
min(a) 返回参数a(序列或者元祖的最小值)
Sum(a) 返回和 以上四者都需要 元素是统一的才可以
Sorted() 排序
Reversed() 反转 其结果并不是反转后的元祖 而是一=一个迭代器 我们使用：
Tuple(Reversed()) 或者list(Reversed()) 即可返回反转后的元素
嗯
list(enumerate(a)) 枚举类型 a是一个列表 enumerate(a) 返回一个迭代器 需要加list 才可显示
[(0, 1), (1, 2), (2, 1), (3, 3), (4, 4), (5, 12)]
字典：
字典用大括号定义 字典不是序列类型，他是映射类型，不能用索引来访问。
dir1={‘李宁‘:‘一切皆有可能‘,‘耐克‘:‘imposible is nothing‘,‘安踏‘:‘永不止步‘,}
李宁 是key 一切皆有可能就是值 value 他们用冒号隔开
索引：
print(‘安踏的口号是：‘,dir1[‘安踏‘])
安踏的口号是： 永不止步
例：dir2={1:‘zhang‘,2:‘rui‘,3:‘lin‘}
>>> dir2
{1: ‘zhang‘, 2: ‘rui‘, 3: ‘lin‘}
创建字典： dirct1={};
使用dict函数 dict 仅是一个参数
dirt3=dict(((1,‘zhang‘),(2,‘rui‘),(3,‘lin‘))) 所以要将三个元祖伪装成一个元祖 即三个括号（仔细理解下）
>>> dirt3
{1: ‘zhang‘, 2: ‘rui‘, 3: ‘lin‘}
修改字典元素 原本：{1: ‘zhang‘, 2: ‘rui‘, 3: ‘lin‘}
dirt3[1]=‘dashibi‘
>>> dirt3
{1: ‘dashibi‘, 2: ‘rui‘, 3: ‘lin‘} 即若字典中没有该索引，则自动添加一个。
Fromkeys 创建一个新的键值 并返回 注意：只能定义 不能用于修改字典中的元素
dict5=dict5.fromkeys((1,2,3),(‘one‘,‘two‘,‘three‘))
输出：
{1: (‘one‘, ‘two‘, ‘three‘), 2: (‘one‘, ‘two‘, ‘three‘), 3: (‘one‘, ‘two‘, ‘three‘)}
dict5=dict5.fromkeys(1,(‘one‘,’zhang’) 以为修改字典中的第一个元素 ，其实不是、
输出 dict5 为 1：zhang 即变成了一个新的字典
e=dict5.fromkeys(range(12),‘叼‘)
>>> e
{0: ‘叼‘, 1: ‘叼‘, 2: ‘叼‘, 3: ‘叼‘, 4: ‘叼‘, 5: ‘叼‘, 6: ‘叼‘, 7: ‘叼‘, 8: ‘叼‘, 9: ‘叼‘, 10: ‘叼‘, 11: ‘叼‘}
Keys()用法
>>> for i in e.keys():
print(i)
0
1
2
3
4
5
6
7
8
9
10
11
>>>
values()用法
>>> for i in e.values():
print(i)
叼
叼
叼
叼
叼
叼
叼
叼
叼
叼
叼
叼
>>>
获取元素
get() 方法
检查索引值是否有
例如 检查 键值32
直接 32 in e 有就返回真 没有进返回 假
In not in 是成员资格操作符
清空字典
Clear（）
Pop() 给定键弹出一个值
Popitem() 弹出一个项
Setdefault(5,’baba’) 加入键值为5 值为baba
Update() 用一个映射关系去更新字典
dirt3={1:‘zhang‘,2:‘rui‘,3:‘lin‘}
>>> dirt3
{1: ‘zhang‘, 2: ‘rui‘, 3: ‘lin‘}
>>> dirt3.pop(1)
‘zhang‘
>>> dirt3
{2: ‘rui‘, 3: ‘lin‘}
>>> dirt3
{2: ‘rui‘, 3: ‘lin‘}
>>> dirt3.setdefault(6,‘baba‘)
‘baba‘
>>> dirt3
{2: ‘rui‘, 3: ‘lin‘, 6: ‘baba‘}
>>> b={‘小白‘:‘gou‘}
>>> dirt3.update(b)
>>> dirt3
{2: ‘rui‘, 3: ‘lin‘, ‘小白‘: ‘gou‘, 6: ‘baba‘}
集合：
和字典是表兄弟
>>> jihe={12,3,4} 也是用大括号
>>> type(jihe)
<class ‘set‘> 这是集合 与字典的定义很像
集合的元素是唯一的 重复的元素会被自动剔除
集合是无序的 不能通过索引
创建集合： jihe={1,2,3,,4}
Set() 工厂函数
jihe=set([1,2,3,4]) set（）函数的参数此时为列表 也可以为元祖 或者字符串
>>> jihe
{1, 2, 3, 4}
可以用for 循环去读取 每一个元素
可以用 in not in 判断元素是否在集合中
Add（1） 加入元素1
Remove（1） 移除元素1
文件操作
f=open(‘E:\\recovery.txt‘,‘rt‘) 打开E盘下的recovery文件 只读模式 f为文件对象
f.read() 读取全部
‘张锐UI安徽人房间卡收费方式告诉\n哈弗达就开始放假阿喀琉斯\n爱上飞机哈克龙师傅就爱上了咖啡\nafsjkfnalkf、\n爱就开始发贺卡叫师傅好\n‘
此时的read指针指向最后了
>>> f=open(‘E:\\recovery.txt‘,‘rt‘)
>>> f.read(4) 读五个字符
‘张锐UI‘
>>> f.tell() 读出指针所在的位置
7
Python 很灵活
可以把文件对象转化为list 列表
>>> f=open(‘E:\\recovery.txt‘,‘rt‘)
>>> list(f)
[‘张锐UI安徽人房间卡收费方式告诉\n‘, ‘哈弗达就开始放假阿喀琉斯\n‘, ‘爱上飞机哈克龙师傅就爱上了咖啡\n‘, ‘afsjkfnalkf、\n‘, ‘爱就开始发贺卡叫师傅好\n‘] 即把内容包含起来了
每一行都读取出来了
>>> f=open(‘E:\\recovery.txt‘,‘rt‘)
>>> a=list(f)
>>> for i in a:
print(i)
张锐UI安徽人房间卡收费方式告诉
哈弗达就开始放假阿喀琉斯
爱上飞机哈克龙师傅就爱上了咖啡
afsjkfnalkf、
爱就开始发贺卡叫师傅好
写入文件:
>>> file=open(‘E:\\test.txt‘,‘w‘)
>>> file.write(‘zhangruilin‘) 写入 zhangruilin
11
>>> file.seek(0,0) 指针归零
0
>>> for i in file: 输出
print(i)
模块：
OS模块中关于文件的一些操作
Import os 导入模块
os.getcwd()
os.listdir(‘E:\\‘)
os.mkdir(‘C:\\B‘)
>>> os.remove(‘D:\\从.jpg‘)
>>> os.rmdir(‘C:\\B‘)
Os.path 模块很有用
Pickle模块
可以用到保存文件，保存为各种类型的文件，不仅仅局限于文本文件
将列表 字典 等复杂的数据类型 转化为 二进制文件。
>>> m_list=[123,3.14,‘zhangruilin‘,[‘answer‘]]
>>> pickl_file=open(‘my_list.pkl‘,‘wb‘) 后缀名无所谓 内容是不会改变的 WB 只读二进制 保存步骤
>>> pickle.dump(m_list,pickl_file) 保存文件
>>> pickl_file.close()
>>> pickl_file=open(‘my_list.pkl‘,‘rb‘)
>>> my_list=pickle.load(pickl_file) 回复出整个列表 读出步骤
>>> my_list
[123, 3.14, ‘zhangruilin‘, [‘answer‘]]
举例子： 将一些不必要的文件都通过 pickle模块 保存
>>> m_list1=[‘123‘,‘234‘]
>>> pickle1=open(‘C:\\zhangruilin.pkl‘,‘wb‘)
>>> pickle1=open(‘C:\\zhangruilin.pkl‘,‘wb‘)
>>> pickle.dump(m_list1,pickle1)
>>> pickle1.close()
>>> pickle1=open(‘C:\\zhangruilin.pkl‘,‘rb‘)
>>> a=pickle.load(pickle1)
>>> a
[‘123‘, ‘234‘]
异常：
try :
f=open(‘C:\\AC.txt‘,‘w‘)
print(f.write(‘我存在了‘))
sum=1+‘1‘
f.close()
except (OSError,TypeError) :
print(‘出错啦‘)
finally:
f.close()
丰富的else语句 else 能和while 和 try 匹配
当while中不执行了 就执行接下来的else语句
当try中没有错了，会执行else语句
try :
f=open(‘C:\\AC.txt‘,‘w‘)
print(f.write(‘我存在了‘))
sum=1+‘1‘
f.close()
except (OSError,TypeError) :
print(‘出错啦‘)
Else:
Print(‘zhangrui;in’) 当try中没有错误了 就会执行else中的
a=1
while a!=2:
print(‘nishishiba‘)
A++
else: 当while不执行了 就执行else语句
print(‘sadiyage‘)
With语句 抽象出文件的一些常见操作，帮助我们自动关闭文件
try :
With open(‘C:\\AC.txt‘,‘w‘) as f: with 会关注这个文件什么时候没有用到 他会自动调用关闭
print(f.write(‘我存在了‘))
sum=1+‘1‘
except (OSError,TypeError) :
print(‘出错啦‘)
Puthon中 类大写字母开头， 函数小写字母开头
Python是面向对象的 继承 封装 多态都有
继承
class a(list): 参数list 表示的含义是 类a 继承list类
Pass 代表此类什么也不做 仅仅是演示
>>> b=a()
>>> b.append(34) 对象b 继承list类的一切功能
>>> b
[34]
Python 的 self 和C++的this指针 即每个类的对象的标识符号（标识一个对象）
定义 注意 在进行类的定义的时候 把self写进第一个参数就可以了
class gun:
def fun(self,name):
self.name=name
def shoot(self):
print(‘the weapon function is %s‘%self.name)
>>> a=gun()
>>> a.fun(‘机枪‘)
>>> b=gun()
>>> b.fun(‘自动步枪‘)
>>> a.shoot()
the weapon function is 机枪
>>> b.shoot()
the weapon function is 自动步枪
魔法方法：
_init_（self,canshu1,canshu2） 功能就是C++的构造函数 注意是双下划线
class Gun:
def __init__(self,name):
self.name=name 当对象建立的时候 自动调用
def shoot(self):
print(‘the weapon function is %s‘%self.name)
>>> b=Gun(‘重机枪‘) 调用的时候不用管第一个参数
>>> b.shoot()
the weapon function is 重机枪
私有变量 Python中定义私有变量 在变量名或者函数名前加上两个下划线
Super.加上需要的父类的方法（） super即可帮我们调用父类定义好的方法
例如：
import random as r
class fish:
def __init__(self):
self.x=r.randint(0,10)
self.y=r.randint(0,10)
def move(self):
self.x-=1
print(‘我的位置是：‘,self.x,self.y)
class goldfish(fish):
pass
class salman(fish):
pass
class carp(fish):
pass
class shark(fish):
def __init__(self):
super().__init__() 不用给定任何基类的名字
self.hungry=True
def eat(self):
if self.hungry:
print(‘吃货的梦想就是天天吃‘)
self.hungry=False
else:
print(‘吃饱了，吃不下了‘)
>>> Shark=shark()
>>> Shark.move()
我的位置是： 9 1