Python 2.7 基础 - Python - 程序员开发

TOP

Python 2.7 基础

2019-01-21 02:56:11 【大中小】浏览:54次

Tags：Python 2.7 基础

Python能够直接处理的数据类型

整数

浮点数

例：3.33x1010 1.23e10 , 0.00033 3.3e-4

字符串

以' '或 " "括起来，如果字符串本身包含' '，可以用" "，反之亦然同时包含' '和" "，需要用 \（反斜杠）进行转义常见转义字符\n（换行） \t（一个制表符） \\（\字符本身）

row字符串：在字符串前面加一个r

r'(内容)'

表示里面的字符不需要转义（不能表示多行字符串，注意区分''和""的匹配）

''' (内容)
    (内容)
    (内容)'''

可表示多行字符串（前面也可加r变成row字符串输出）

编码问题

print u'中文'（以Unicode表示的字符串）

# -*- coding:utf-8 -*-（如果开头指定utf-8编码，print时可以不加u）

编码区别（链接：https://www.zhihu.com/question/23374078/answer/69732605）

中国人民通过对 ASCII 编码的中文扩充改造，产生了 GB2312 编码，可以表示6000多个常用汉字。

汉字实在是太多了，包括繁体和各种字符，于是产生了 GBK 编码，它包括了 GB2312 中的编码，同时扩充了很多。

中国是个多民族国家，各个民族几乎都有自己独立的语言系统，为了表示那些字符，继续把 GBK 编码扩充为 GB18030 编码。

每个国家都像中国一样，把自己的语言编码，于是出现了各种各样的编码，如果你不安装相应的编码，就无法解释相应编码想表达的内容。

终于，有个叫 ISO 的组织看不下去了。他们一起创造了一种编码 UNICODE ，这种编码非常大，大到可以容纳世界上任何一个文字和标志。所以只要电脑上有 UNICODE 这种编码系统，无论是全球哪种文字，只需要保存文件的时候，保存成 UNICODE 编码就可以被其他电脑正常解释。

UNICODE 在网络传输中，出现了两个标准 UTF-8 和 UTF-16，分别每次传输 8个位和 16个位。于是就会有人产生疑问，UTF-8 既然能保存那么多文字、符号，为什么国内还有这么多使用 GBK 等编码的人？因为 UTF-8 等编码体积比较大，占电脑空间比较多，如果面向的使用人群绝大部分都是中国人，用 GBK 等编码也可以

布尔值

True False（注意大小写）可用and or not运算

Python把0，空字符串''，None看成False，其他数值和非空字符串看成True

在 andor 运算时，如果两边的结果都相同，根据就近原则，python会返回运算正确与否取决于的一边

空值

None（注意不能理解为0）

Python中print

,（逗号）翻译为空格例如：print 'hello','python'

Python中注释

前面加#，作用范围从#开始一直到这一行末尾

Python中变量

变量是用一个变量名表示，变量名必须是大小写英文、数字和下划线的组合，且不能用数字开头，用=赋值

=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量

直接赋值（例 a=333,a='abc'）这种变量本身类型不固定的语言称为动态语言

定义变量时指定变量类型的（例inta = 333;a=10;）称为静态语言（注意赋值时同一类型）

Python中四则运算

规则一致，可以类比C语言（注意区分整数与浮点数）

list

列表，有序的集合，可以随意添加删除其中的元素

Python是动态语言，list中可以包含各种数据

l=['Victor',100,'AchanZhang-',99]

可以为空

empty_list=[]

Python按照索引访问list（类比C语言数组）

索引从0开始，不能越界超出元素个数范围

-1为倒数第一位元素，以此类推，依然注意不能越界

添加

l.append('')把新元素添加到list的尾部

l.insert(索引,'')把内容添加到指定索引位置

删除

l.pop()删掉list的最后一个元素，并且它还返回这个元素

l.pop(索引)删除指定索引位置的元素

替换

对一个索引赋值l[0]='Z'

tuple

元组，有序的列表，tuple一旦创建完毕，就不能修改了（t=(内容)，注意使用小括号）

除了不能增删改外，依然通过索引进行元素访问

可以为空t=()

Python规定，单元素tuple要多加一个逗号，避免歧义（括号在运算中表示优先级），t=(1,)，多元素时末尾任意

tuple不能修改指每个元素指向不变，如果指向一个list，可以改变list的值

t=('a','b',['A','B'])
l=t(2)
l[0]=''
l[1]=''

if语句

if条件:
    print
    print
print

注意：Python的缩进为4个空格，具有相同的缩进的代码被视为代码块)

在Python的交互环境下，特别留意缩进，并且退出缩进需要多敲一行回车

if...else...语句，if和else后面都要加冒号

if...elif...else这一系列条件判断会从上到下依次判断

for循环

迭代list或tuple

for 一个变量 in l(l为一个list):
    执行语句

for循环中定义一个变量，依次取出list中的每一个元素，赋值给变量

while循环

while循环根据表达式判断循环是否结束，防止进入死循环，要特别留意while循环的退出条件（while True:就是一个死循环）

break语句

在循环体内直接退出循环

continue语句

跳过后续循环代码，继续下一次循环

多重循环

for x in ['A','B','C']:
    for y in ['1','2','3']:
        print x+y

输出：A1 A2 A3 B1 B2 B3 C1 C2 C3

dict（dictionary字典）

用dict表示“名字”-“成绩”的查找表，名字称为key，对应的成绩称为value，dict就是通过key来查找value（d[key]）

d={
    'Victor' : 100,
    'AchanZhang' : 98,
    'StubbenFoodie' : 99
    }

注意，判断key

1.先判断一下key是否存在，用in操作符

if 'A' in d:

    print d['A']

2.使用dict本身提供的一个get方法，在key不存在时，返回None

print d.get('A')

特点

1.查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样，而list的查找速度随着元素增加而逐渐下降。缺点是dict占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。dict是按key查找，所以，在一个dict中，key不能重复

2.存储的key-value序对是没有顺序的，打印的顺序不一定是我们创建的顺序，而且，不同的机器打印的顺序可能不同，不能用dict存储有序的集合

3.作为key的元素必须不可变，字符串、整数、浮点数、tuple都是不可变的，都可以作为key，但list是可变的，不能作为key

更新dict

直接进行复制，相同的key则覆盖（d['AAA']=95）

遍历dict

d={
    'Victor' : 100,
    'AchanZhang' : 98,
    'StubbenFoodie' : 99
    }
for key in d:
    print '%s: %d'%(key,d[key])

set

set持有一系列没有重复和无序的元素 s=set(['A','B','C'])

创建set的方式是调用set()并传入一个list，list的元素将作为set的元素，如果出现重复的元素，set会自动去掉重复的元素

特点

set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快（可以用来快速判断输入的月份和星期）

set存储的元素和dict的key类似，必须是不变对象

for循环遍历set

s=set([('Victor',100),('AchanZhang',98),('StubbenFoodie',99)])

for x in s:

    print x[0]+':',x[1]

更新set

s.add(内容)添加的元素已经存在set中，add()不会报错。但是不会加进去了

s.remove(内容)删除的元素不存在set中，remove()会报错

Python函数

abs(100)求绝对值

cmp(x,y) x<y返回-1，x==y返回0，x>y返回1

int('123')/int(12.34) 123/12可以把其他数据类型转化为整数

str(123)/str(1.23) '123'/'1.23'把其他类型转换成str字符串

sum(L)接受一个list作为参数，并返回list所有元素之和

range(1,101)创建一个数列[1,2,3,...,100]

zip([1,2,3],[A,B,C])把两个list变成一个list [(1,A),(2,B),(3,C)]

isinstance(x,str) 可以判断变量x是否是字符串

方法

str.upper() 把所有字符中的小写字母转化成大写字母

str.lower() 把所有字符中的大写字母转化成小写字母

str.capitalize() 把第一个字母转化为大写字母，其余小写

str.title() 把每个单词的第一个字母转化为大写，其余小写

函数是一段代码，通过名字来进行调用。它能将一些数据（参数）传递进去进行处理，然后返回一些数据（返回值），也可以没有返回值。所有传递给函数的数据都是显式传递的。

方法也是一段代码，也通过名字来进行调用，但它跟一个对象相关联。方法和函数大致上是相同的，但有两个主要的不同之处：方法中的数据是隐式传递的；方法可以操作类内部的数据（请记住，对象是类的实例化–类定义了一个数据类型，而对象是该数据类型的一个实例化）

编写函数

定义一个函数要使用def语句，一次写出函数名、括号、括号中的参数和冒号，然后在缩进块中编写函数体，函数的返回值用return，函数体内部的语句在执行时，一旦执行到return，函数就执行完毕，并将结果返回，如果没有return语句，函数执行完毕后也会返回结果，知识结果为None，retuen None可以写成return

定义一个计算list平方和的函数：

def squre_of_sum(L):
    sum=0
    for x in L:
        sum=sum+x*x
    return sum

print squre_of_sum([1,2,3,4,5])

函数返回多值

Python引用包用import

return返回多个结果，返回的是一个tuple

在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋值给对应的值

定义一个解一元二次方程的函数（ax2+bx+c=0）：

import math
def quadratic_equation(a,b,c):
    d=b*b-4*a*c
    if d>0:
    x1=(-b+math.sqrt(d))/(2*a)
    x2=(-b-math.sqrt(d))/(2*a)
    return x1,x2
    else:
        return

print quadratic_equation(2,3,0)

递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出

定义一个计算阶乘的函数：

def fact(n):
    if n==1:
        return 1
    return n*fact(n-1)

汉诺塔问题：

def move(n,a,b,c):
    if n==1                         #如果a柱子上只有一个盘子，则直接移到c柱子上面去并输出路径结束递归
        print a,'-->',c
        return
    move(n-1,a,c,b)            #将n-1的盘子从a柱子上面移到b柱子上面去
    print a,'-->',c                #输出最下面个盘子从a移动到c的路径
    move(n-1,b,a,c)            #将b柱子上面的n-1个盘子移动到c柱子上面
                                   #（注意以上a、b、c的位置的交换）
    move(4,'A','B,'C')

函数定义默认参数

int('123',8) 83(把8进制123转化为10进制) int()的第二个参数是转换进制，如果不传，默认是十进制（base=10），如果传了，就用传入的参数

函数的默认参数的作用是简化调用，你只需要把必须的参数传进去。但是在需要的时候，又可以传入额外的参数来覆盖默认参数值

由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必须参数的后面，deffn(a,b,c='world')

可变参数

如果想让一个函数能接受任意个参数

deffn(*args):
    print args

可变参数的名字前面有*号，我们可以传入0个、1个或多个参数给可变参数，Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，在函数内部，直接把args看成一个tuple就好了，用sum(args)计算之和，用len(args)计算个数

切片

对list进行切片，tuple完全相同

l[0:3]从索引0开始取，直到索引3为止，但不包括索引3.即索引0,1,2

l[:3] 如果第一个索引是0，还可以省略

l[:] 只用一个：表示从头取到尾

l[::2] 第三个参数表示每N个取一个，这里表示每两个元素取出来一个（可用来表示多少的倍数）

倒序切片

第一个元素的索引是-1

对字符串切片

字符串可以看成是一种list，每个元素就是一个字符，也可以用切片操作，只是操作结果仍是字符串

'hello'[:3]

'hel'

迭代

在Python中，如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代（Iteration），通过for...in来完成的，for循环不仅可以用在list或tuple上，还可以作用在其他任何可迭代对象上，迭代操作就是对于一个集合（指包含一组元素的数据结构），无论该集合是有序还是无序，我们用for循环总是可以依次取出集合的每一个元素，迭代是一个动词，它指的是一种操作，在Python中，就是for循环

迭代与按下标访问数组最大的不同是，后者是一种具体的迭代实现方式，而前者只关心迭代结果

有序集合：list tuple str unicode

无序集合：set

无序集合并且具有key-value对：dict

索引迭代

Python中迭代是取出元素本身，而非元素的索引

对于有序集合，元素确实是有索引的，想在for循环中拿到索引，用enumerate()函数，函数把索引和元素结合起来，把迭代的每一个元素变成一个tuple，意思是每个tuple包含两个元素

for index,name in enumerate(L):

    print index,'-',name

迭代dict的value

dict对象本身是可迭代对象，用for循环直接迭代dict，可以每次拿到dict的一个key，如果想要迭代dict对象的value，需用用函数d.values()，或者d.itervalues()

两者迭代效果一样

values()方法实际上把一个dict转换成了包含value的list

itervalues()方法在迭代过程中依次从dict中取出value

所以itervalues()方法比values()方法节省了生成list所需的内存

如果一个对象说自己可迭代，那我们就直接用for循环去迭代它，可见，迭代是一种抽象的数据操作，它不对迭代对象内部的数据有任何要求

迭代dict的key和value

把dict对象转换成包含tuple的list

d.items() d.iteritems()

列表

range(1,101,2) [1,3,5,7,9,...99]

如果要生成[1x2,3x4,5x6,7x8,...,99x100]

print[x*(x+1) for x in range(1,100,2)]

这种写法是Python特有的列表生成式，把生成的元素放到最前面，后跟for循环，就可以吧list创建出来

复杂表达式

迭代dict，通过一个复杂的列表生成式把它变成一个HTML表格：

d={''Victor' : 100,'AchanZhang' : 98,'StubbenFoodie' : 99'}
tds=['<tr><td>%s</td><td>%s</td></tr>'%(name,score) for name,score in d.iteritems()]
print '<table>'
print '<tr><th>Name</th><th>Score</th><tr>'
print '\n'.join(tds)
print '</table>'

字符串可以通过%进行格式化，用指定的参数替代%s。字符串的join()方法可以把一个list拼接成一个字符串，最终形成一个表格

条件过滤

列表生成式的for循环后面还可以加上if判断

编写一个函数，它接受一个list，然后把list中的所有字符串变成大写后返回，非字符串元素将被忽略

def toUppers(L):

    return [x.upper() for x in L if isinstance(x,str)]


print toUppers(['Hello','world',101])

多层表达式

for循环可以嵌套，列表生成式中，也可以多层for循环来生成列表

利用3层for循环的循环列表，找出对称的3位数。例如121

print[100*n1+10*n2+n3 for n1 in range(1,10) for n2 in range(10) for n3 in range(10) if n1==n3]

以上来源于慕课网学习自行总结


【大中小】【打印】【繁体】【投稿】【收藏】【推荐】【举报】【评论】【关闭】【返回顶部】

上一篇：小甲鱼python学习	下一篇：Python中sys.path.append和os.env..