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中的值当做一个元组进行输出

变量的作用域

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

你可能感兴趣的:(Python)