找帮助文档   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

python基础语法汇编总结