Python基础学习笔记

Python基础

Python简单函数

注意：Python代码中有中文时，要在代码开头加入#–coding:UTF-8– 或者 #coding=uft-8

#coding=utf-8  #结尾处有中文，则需加入该编码

def p_num():
    num=5
    print num

num=10
p_num()
print num

#结果为：5 10

#函数定义格式
def add(x,y):  #def为定义函数的关键字，add为函数名，x、y为形参不需要类型修饰符
    z=x+y
    return z   #函数可以拥有返回值，若无返回值则返回None
#以上为函数定义

result = add(3,5)   #调用函数
print result

• 局部变量和全局变量

#代码1：局部变量作用域覆盖全局变量
def p_num():
    num=5
    print num

num=10
p_num()
print num
#结果为：5 10

#代码2：函数内有局部变量定义，解释器不使用全局变量，局部变量的定义晚于被引用，报错
def p_num():
    print num
    num=5
    print num

num=10
p_num()
print num
#结果出错

#代码3：函数内部可以直接访问全局变量
def p_num():
    print num

num=10
p_num()
print num
#结果为：10 10

#代码4：函数内修改全局变量，使用global关键字
def p_num():
    global num
    print num
    num = 8

num=10
p_num()
print num
#结果为：10 8

• 算数表达式：

a ** b #a的b次幂
a / b  #a除以b，真正除，浮点数保留小数
a // b #a除以b，向下取整
a % b  #a对b取余

• 逻辑表达式

# 此处所有表达式的取值均为bool值
not a       a的逻辑非
a and b     a和b的逻辑与
a or  b     a和b的逻辑或
a is  b     a和b是同一个对象
a is not b  a和b不是同一对象

• 位运算

~a      按位取反
a << n  a左移n位
a >> n  a右移n位
a & b   a和b按位与
a | b   a和b按位或
a ^ b   a和b按位异或

==语法格式：缩进表示关系；函数，分支，循环语句后面带”:”==

分支语句

# if-else
if a > b;
    print"aaa"
else:
    print"bbb"


# if-elif-else
if a > b:
    print "a>b"
elif a == b:
    print "a==b"
else:
    print "a

循环语句

Python中的循环控制语句与C中相似，==注意语句后的“:”不要丢掉==

#while循环结构

while 判断条件:
    执行语句


#代码1：

var=1
while var==1:
    num=raw_input("Enter a number:")
    print "Your entered:",num
    var+=var

print  "Good Bye!"

# Python for循环可以遍历任何序列的项目，比如一个列表或一个字符串。



# 代码2：遍历一个字符串

for letter in 'Python':
    print 'Python中每个字符为：',letter

代码3：遍历一个列表
fruits=['banana','apple','mango']
for fruit in fruits:
    print '集合中的水果有：',fruit


# Python中，for....else表示：for中的语句和普通的没有区别，else中的语句会在循环正常执行完（即for不是通过break跳出而中断的）的情况下执行，while...else也是一样



# 代码4：

count=0
while count<5:
    print count,'is  less than 5'
    count=count+1
else:
    print count,'is not less than 5'

list列表

列表和元组二者均能保存任意类型的python对象，列表元素用[]包括，可以添加、删除、搜索列表中的项，由于可以添加、删除项目，所以列表属于可变的数据类型；元组元素用（）包括，其项目不能被修改。
通过切片[]、[:]得到子集，此操作同于字符串相关操作

==切片使用的相关样式[下限:上限:步长]；取下限不取上限==

---

#列表的操作



#新建列表

L=[1,2,3,4]


#更新列表中的值

L[1]=5  #中括号中的1是列表元素的索引值

#此时L为：[1,5,3,4]



#删除列表中的值

del L[1]  #中括号中的值为列表元素的索引值

#此时L为：[1,3,4]



#列表中元素出栈

L=[1,2,3,4]
L.pop()  #列表中最后一个元素出栈
print L

#输出结果为：[1,2,3]



#向列表中添加元素,此处可以添加任意类型的元素，列表中还可以追加列表

L=[1,2,3,4]
L.append(12)  #在列表末尾添加指定元素

print  L

#输出结果为：[1,2,3,4,12]

Python列表脚本操作符

==列表对+和的操作符与字符串相似，+号用于组合列表，号用于重复列表==

#计算列表长度：
len([1,2,3,4])  #结果为4

#组合列表：
[1,2,3]+[4,5,6] #结果为：[1,2,3,4,5,6]

#重复列表中元素：
['H1']*4  #结果为：['H1','H1','H1','H1']

#判断元素是否在列表中：返回结果为bool类型
3 in [1,2,3]  #结果为：True

#迭代输出列表中元素：
for x in  [1,2,3]:
    print x
#输出结果为： 1 2 3

列表截取

#从索引为2的元素开始取其后的元素
L=[1,2,3,4,5]
print L[2:]
#输出结果为：[3,4,5]

#取索引为2~4之间的元素（取下限不取上限）
L=[1,2,3,4,5]
print L[2:4]
#输出结果为：[3,4]

元组Tuple（只读列表）

Python的元组与列表类似，不同之处在于元组的元素不能修改，也可进行切片和连接操作，元素定义时使用小括号，列表使用方括号。
==元组中的元素不允许被删除，但可以使用del语句删除整个元组。==

字典Dictionary

字典是Python中的映射数据类型，由key-value键值对构成，key一般以数字和字符串居多，value则可以是任意类型的python对象，字典元素用大括号{}包括。

#字典示例：
dict = {'Alice':'98','Tom':'87','Cecil':'90'} 

每个键与值之间用冒号’:’隔开，每对用逗号分割，整体放在花括号中’{}’。键key必须独一无二，但值则不必。值value可取任何数据类型，但必须是不可变的。

#用for循环遍历字典
dic={'Ben':89,'Tim':97,'Jay':95}
for key in dic:
    print key,dic[key]

字典键key的特性：
字典值可以没有限地任意去任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。==注意以下两点：==
1. 不允许同一个键出现两次，创建时如果同一个键被赋值两次，最后一个值会被记住
2. 键必须不可变，所以可以用数、字符串、元组充当，但列表不行。

Python字符串处理与特殊函数

Python中用引号括起来的字符集合称为字符串，引号可以是一对单引号，双引号，三引号（三个单引号或三个双引号，Python中三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符）。

Python访问字符串中的值

Python不支持单字符类型，单字符也在Python中作为一个字符串使用。
Python访问子字符串，可以使用方括号来截取字符串，即分片操作

Python字符串更新

#将已定义的字符串赋值给另一个变量，然后对其进行字符串连接，不改变原字符串的值

s='Hello World'     #原字符串
s1=s                #赋值给新字符串

print s1[:6]+'Python'  #读取字符串前6个字符，然后将其与目标字符串连接
print s

#输出结果为：Hello Python    Hello World

Python字符串运算符

假设下表中实例变量a的值为“Hello”，b的值为“Python”：

操作符	描述	实例
+	字符串连接	a+b输出结果为：HelloPython
*	重复输出字符串	a*2输出结果为：HelloHello
[]	通过索引获取字符串	a[1]输出结果为：e
[:]	截取字符串中的一部分	a[1:4]输出结果为：ell
in	成员运算符	若字符串中包含给定的字符，则返回True
not in	成员运算符	若字符串中不包含给定的字符串，则返回True
r/R	输出原始字符串	字符串直接按照字面意思输出，没有转译或不能打印的字符

#操作符r/R示例：

print r'Hello World\n\n\n'

#输出结果为：Hello World\n\n\n ;字符串前若无r则输出结果为：Hello World下跟3行空行

Python字符串格式化输出

#代码示例
print 'My name is %s and age is %d'%('Tom',28)

字符串各种函数

测试字符串为：mystr=’Hello World henu and henuer’

1. find()函数：mystr.find(str,start=0,end=len(mystr))  //其中str为要查找的字符串，start为查找开始的索引，end为结束位置的索引（二者可缺省）
//若str不在mystr中输出-1
mystr='Hello World henu and henuer'
print mystr.find('henu')  //输出结果为目标字符串的首字母索引值，此处为：12
print mystr.find('henu',13，len(mystr))  //给定起始索引值，此处输出结果为：21

2.index()函数：跟find()函数类似，不同之处在于，如果str不在mystr中会抛出异常

3.count()函数：用来统计子串在母串中出现的次数

mystr='Hello World henu and henuer'
print mystr.count('henu')  //输出结果为：2

4.decode()函数：按照指定的编码格式进行解码
代码格式：mystr.decode(encoding='编码格式',errors='strict')  //以encoding指定的编码格式解码mystr，如果出错报一个ValueEeror的异常，除非errors指定的是'ignore'或者'replace'，此时解码出错不会抛异常

mystr='Hello World henu and henuer'
mystr.decode(encoding='utf-8')
//输出结果为：u'Hello World henu and henuer'（本结果在IDLE编译器中得到）

5.replace()函数：把mstr中的str1替换为str2，如果count指定，则替换不超过count次
代码格式：mystr.replace(str1,str2,mystr.count(str1))  //替换的最大次数为:mystr.count(str1)次

mystr='Hello World henu and henuer'
print mystr.replace('henu','rjxy')  //输出结果为：Hello World rjxy and rjxyer
//replace()函数执行后，不改变原字符串的值，除非重新赋值，如下：
mystr='Hello World henu and henuer'
mystr=mystr.replace('henu','rjxy')
print mystr  //此时原字符串被改为：Hello World rjxy and rjxyer

6.split()函数：以str为分隔符切片mystr，如果maxsplit有指定值，则仅分隔maxsplit个子字符串
代码格式：mystr.split(' ',maxsplit)  //单引号中为指定分隔字符（此处为空格）,maxsplit可缺省
//分割后得到一个列表

mystr='Hello World henu and henuer'
print mystr.split(' ')   //输出结果为：['Hello', 'World', 'henu', 'and', 'henuer']

mystr='Hello World henu and henuer'
print mystr.split(' ',2)  //此时输出结果为：['Hello', 'World', 'henu and henuer']，只在前两个空格处分隔字符串

7.capitalize()函数:把字符串的第一个字符大写

mystr='hello world henu and henuer'
print mystr.capitalize()  //输出结果为：Hello world henu and henuer

8.center()函数：返回一个原字符串居中，并使用空格填充至长度width的新字符串
代码格式：mystr.center(width) //width为指定长度

mystr='hello world henu and henuer'
print mystr.center(60)

9.startswith()/endswith()函数：判断一个字符串是否以指定字符串开头或结尾，返回值为bool类型

mystr='hello world henu and henuer'
print mystr.startswith('hello')  //结果为：True
print mystr.endswith('hello')  //结果为：False

10.isalnum()函数：如果mystr至少有一个字符并且所有字符都是字母或数字则返回True，否则返回False（如果字符串中含空格等特殊字符，返回结果为False）

mystr='helloworldhenuandhenuer'
print mystr.isalnum()  //结果为True

11.isalpha()函数：如果mystr至少有一个字符并且所有字符都是字母（不含数字和空格）则返回True，否则返回False

mystr='helloworldhenuandhenuer'
print mystr.isalpha()  //结果为True

12.isdigit()函数：如果mystr中只包含数字则返回True，否则返回False

s1='123456'
print s1.isdigit()  //结果为：True

13.islower()函数：判断字符串中字母是否都是小写，全是小写返回True，否则返回False

mystr='helloworldhenuandhenuer'
print mystr.islower()  //结果为：True

14.isupper()函数：判断字符串中字母是否都是大写，全是大写返回True，否则返回False

15.isspace()函数：如果mystr中只包含空格则返回True，否则返回False

s1='   '
print s1.isspace()  //结果为：True

16.join()函数：mystr中每个字符后面插入str，构造出一个新字符串
//代码格式：mystr.join(str)
s1='hello'
print s1.join('xxxx')  //结果为：xhelloxhelloxhellox

17.ljust()函数：返回一个原字符串左对齐，并使用空格填充至长度width的新字符串(在右边填充空格)
//代码格式：mystr.ljust(width)  width新字符串长度

18.rjust()函数：返回一个源字符串右对齐，并使用空格填充至长度width的新字符串(在左边填充空格)

19.lstrip()函数：截掉mystr字符串左边的空格
//代码格式：mystr.lstrip()

20.rstrip()函数：删除mystr字符串末尾的空格

21.rfind()函数：类似于find()函数，不过rfind()函数是从右边开始查找
//使用时与find()相同

22.rindex()函数：类似于index()函数，rindex()函数是从右边开始
//使用时与index()相同

23.partition()函数：把mystr以str中心分割成三部分：str前，str，str后；输出结果为一个元组
//若str为mystr中的开头子串，则输出元组的第一个元素为空
//若str为mystr的尾子串，则输出元组的最后一个元素为空
mystr='hello world henu and henuer'
print mystr.partition('henu')  //结果为：('hello world ', 'henu', ' and henuer')
print mystr.partition('hello')  //结果为：('', 'hello', ' world henu and henuer')
print mystr.partition('henuer')  //结果为：('hello world henu and ', 'henuer', '')

24.rpartition()函数：类似于partition()函数，不过是从右边开始
//代码格式：mystr.rpartition(str)

25.splitlines()函数：按行分隔，返回一个包含各行作为元素的列表

26.zfill()函数：返回长度为width的字符串，原字符串mystr右对齐，左边填充0
//代码格式:mystr.zfill(width)
s1='hello'
print s1.zfill(8)  //结果为：000hello

函数高级

定义一个函数

#语法
def functionname( 函数参数 ):
    "函数_文档字符串（对函数的注释）"
    function_suite #函数体
    return [experssion] #返回值
#默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。

#示例
def printme(str):
    "打印传入的字符串"
    print str
    return
printme('Hello World')  #函数调用，结果为：Hello World

按值传递参数和按引用传递参数

1. 按值传递，单个变量
2. 按引用传递：如果在函数中修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了

#示例
mylist=[6,7,8]
def changme(mylist):
    "修改传入的列表"
    mylist.append([1,2,3,4])
    print "函数内取值：",mylist
    return

changme(mylist)
print "函数外取值：",mylist
#输出结果为：函数内取值： [6, 7, 8, [1, 2, 3, 4]]
#           函数外取值： [6, 7, 8, [1, 2, 3, 4]]
#传入函数和在末尾新添加内容的对象用的是同一个引用，所以会得到以上输出结果

参数

调用函数时可以使用的正式参数类型：
1. 必备参数
2. 命名参数
3. 缺省参数
4. 不定长参数

必备参数：
必须以正确的形式传入函数，调用时的数量必须和声明时的一样

命名参数：
命名参数和函数调用关系紧密，调用方用参数的命名确定传入的参数值

缺省参数：
调用函数时，缺省参数的值如果没有传入，则被认为是默认值。

不定长参数：

#基本语法
def functionname([formal_args,] *var_args_truple):
    "函数_文档字符串（对函数的注释）"
    function_suite #函数体
    return [experssion] #返回值
加了星号(*)的变量名会存放所有未命名的变量参数。

#示例1：
def arglist(a,*b):   #*b来接受传入的多个参数，*b之前可以有多个参数
    print a
    print b
    return
arglist(1,2,3,4,5,6)    #结果为：1  (2, 3, 4, 5, 6)

#示例2：
def arglist(a,**b):  #**b把传入的值处理成了字典
    print a
    print b
    return
arglist('aa',x=12,y=20)   #结果为：aa  {'y': 20, 'x': 12}

#示例3：
def arglist(**a):
    print  a
    for key in a:
        print key + '=' + str(a[key])

arglist(x=12,y=23,z=63)     #结果为：{'y': 23, 'x': 12, 'z': 63} y=23 x=12 z=63

匿名函数

用lambda关键字能创建小型的匿名函数，这种函数省略了用def声明函数的标准步骤。lambda函数能接收任何数量的参数但只能返回一个表达式的值。匿名函数不能直接调用print，因为lambda需要一个表达式。

lambda函数语法结构：
lambda [arg1 [,arg2,……,argn]]:表达式

//示例：
sum=lambda a,b:a+b
print sum(2,3)  //结果为：5

return语句

return语句[表达式]退出函数，选择性地向调用方返回一个表达式。

#示例：
def arglist():
    print "Hello"
    return 1,2,3,4,5
print arglist()  #结果为：Hello   (1, 2, 3, 4, 5)
#此处return中的值当做一个元组进行输出

变量的作用域

一个程序的所有变量并不是在所有位置都可以访问的。访问权限取决于其在哪赋值。
根据作用域的不同，变量可以分为：全局变量和局部变量。（少用全局变量）