码迷,mamicode.com
首页 > 编程语言 > 详细

python基础语法汇编总结

时间:2016-09-05 12:00:24      阅读:160      评论:0      收藏:0      [点我收藏+]

标签:

找帮助文档   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基础语法汇编总结

标签:

原文地址:http://www.cnblogs.com/zhangruilin/p/5841596.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!