Python学习笔记

关键字

关键字不允许作为标识符使用。 

type()函数：查看变量类型

sum()函数：将数值进行加法运算求和

若前面将函数进行赋值，后可用del()后函数对被赋值的函数进行回收，而后回复原本函数的功能。

Python解释器可将 -5~256存放在一个小整数池里，就不需要其他空间对其进行分配地址空间。

输入函数与输出函数

input() ：实现从标准输入（键盘）中读入一个字符串

input().split()：输入多个值在一行中实现

例如：a,b=input().split()

12 34

a=12  b=34

print()：实现将括号里的内容进行打印输出，会默认以换行符作为输出结束

数字类型

整数：可正可负，整数采用十进制，其他进制需要引进相应的引导符号

整数不同进制的表示

进制                前导符      示例     十进制

二进制            0b或0B     0b10         2

八进制            0o或0O    0o10         8

十六进制        0x或0X     0x10        16

浮点数：取值范围与实数都有限制

浮点数运算存在不确定尾数，有偏差。此时可以用round()函数进行约等于运算

函数格式：round（运算式子，保留几位小数）

复数（complex）：由实部和虚部构成，可用于创建一个复数

例如：complex(2,3)------2+3j

算术运算符

 PS：（整数除法时，结果取数轴靠左的整数）

字符串

是以引号括起来的任意文本

表示形式：

单引号：'Hello'     双引号："Hello"     三引号：‘“Hello World'"

 

转移符号 

                                                                 

                                                                字符串运算符

 

字符串切片：

 顺序可以正向递增，也可反向递减

索引：在 [ ] 中给出序号

切片：在 [ ] 给出切片序号范围
例如：

s="abcdefgh"

s[0] >> a      s[-1] >> h    s[1:5]>> bcde

布尔值：Ture、False

关系运算符

 

实例

 逻辑运算符

与        任意一个不相同则为False

或        只要其中一个满足则为True

非        取反

实例

 优先级和结合级实例

内置转换函数

 实例

 ps：bool()里面的字符串只要非零就为True

实例

 ps：int("    3   5     ")这种表示会出现error

int("35",8)将八进制35转换为十进制29

 

ord()函数和chr()函数 

bin()函数、oct()函数、hex()函数

赋值语句

x=1            y=1

k=x+y        k=2

x,y=4,8         x=4        y=8

x,y="ab"        x=a        y=b

交换值

a,b=b,a        a=8        b=4

两个元素存放多个数

i,j=[1,2,3] ×

i,*j=[1,2,3]        i=1        j=[2,3]

分支语句

if 逻辑表达式：（为真)

                语句块1

else：              （为假)

                语句块2

循环语句

for  variable(变量) in  列表(范围)：

                语句块(执行次数由多少个值决定）

例

for i in [1,2,3,4]:

        print(i,end=' ')

>>>1 2 3 4

产生范围的函数

 例

list(range(10))

>>>[0,1,2,3,4,5,6,7,8,9]

list(range(1,10))

>>>[1,2,3,4,5,6,7,8,9]

list(range(1,10,4))

>>>[1,5,9]

也可以递减

 

应用问题

求n！

n=int(input())

f=1

l=list(range(1,n+1))

for i in l:

        f=f*i

print(f)

 

列表推导式 

例

nl=[2*number for number in [1,2,3,4,5]

>>>nl

[2,4,6,8,10]

format()函数

 

序列类型容器

容器：存放东西的地方

例

s1=[1,2,3]         s1就是一个容器

s2=[4,5,6]

s3=s1+s2

>>>s3

[1,2,3,4,5,6]         s1+s2将容器s3扩大了

判断某元素是否在容器中

例

t=[1,2,3]

>>>1 in t

True

>>>[1,2] in t

Flase

t=[[1,2],3]

>>>[1,2] in t

True

取单个元素

一、

t1=[1,2,3]

>>>t1[0]

1

>>>t1[1]

2

二、

>>>t1=[1,2,3][2]

3

>>>t1=[1,2,3][-1]

3

>>>t1=[1,2,3]

>>>t1[0]

1

>>>t1[0]=4

>>>t1

[4,2,3]

这是数字赋值，但字符串并不支持赋值

例

t1='123'

t1[0]='4'

>>>error

三、

t1='123'

>>>t1[len(t1)-1]

3

列表切片 

sfz='478934199708027121'

>>>sfz[6:14]

'19970802'

如果字符太长，可用以下方法

>>>'1234456'[0:-1] ([:-1])

'123445'

[:1] 该形式默认从0开始

若

>>>'zhejiang'[3:]

'jiang'

[3:] 默认到最后一个结束

序列的函数

len()        计算序列长度

例

>>>s1[1,2,3]

>>>len(s1)

3

max() 和 min()        找出序列中的最大和最小元素

>>>max(s1)

3

>>>min(s1)

1

如果出现想输出以下字符串

It's a good day.

但是‘It' a good day.'中'It'已经组成了一个字符串就无法得到想要的字符串

解决方案：

"It's a good day."        改为双引号

or        'It\'s a good day'        利用一个反斜杠\

\'表示一个单引号 但并不表示结束

三引号的应用'''

例

>>>s='''This

is

a

test.

'''

>>>s

'This\nis\na\ntest.\n'

但如果

>>>print(s)

This

is

a

test.

若>>>s='this\

is\

a\

test.\

>>>s

'thisisatest.'        并没有输出反斜杠\

>>>print(s)

'thisisatest.'

上面反斜杠的意思表示语句没有结束，下一行的要紧跟着上一行

>>>s=r'this\nis\na\ntest.'

>>>s

'this\\nis\\na\\ntest.'

>>>print(s)

this\nis\na\test.

r在这里的作用表示这个字符串是一个原始字符串，字符串里的反斜杠\是不被当初转义字符的前缀，所以所有的反斜杠\会被python的解释器重新还原成两个转义字符的形态

字符串函数

某个字符串加上一个点. 后面再加上函数才可以使用

lower():将字符串里的所有大写字母变成小写字母

例

>>>s='John Smith'

>>>s

'John Smith'

>>>s1=s.lower()

>>>s1

'john smith'

但s不会改变大小写

find():找到指定字符在字符串中所在位置

例

>>>s.find('hn')

2

>>>s.find('aa')

-1        没有找到返回-1

另一种用法：

>>>'Hello World'.find('l')

2

>>>'Hello World'.find('l',3)

3

find(想查找的字符，从第几个字符开始从左往右进行查找)

count()：记录字符出现的次数

例

>>>'Hello World'.count('l')

3

strip()：去掉左右两边的空格

例

>>>s=' Hello World '

>>s.strip()

'Hello World'

>>>s.rstrip()        将右边的空格去掉

' Hello World'

>>>s.lstrip()        将左边的空格去掉

'Hello World '

replace(）：将字符串里的某个字符替换成另一个字符

例

>>>s.replace(' ','')

'Hello Wolrd'

>>>s.replace(' ','-')

‘-Hello-World-'

百分号%的应用

字符串和数字之间的转换

例

一.

>>>'I am %d years old' %18

'I am 18 years old'

二.

>>>'I am %d years old and weight %d kg' %(18,60)        出现多个%d需要用括号

'I am 18 years old and weight 60 kg'

三.

>>>'It is %.1fC' %25.562        %.数字 代表保留小数点后几位

'It is 25.6C'

四.

>>>'It is %5dC' %25        %数字 代表前面空多少格（包括输入数的位置）

'It is    25C'

list()：将括号里的元素转成列表

例

>>list('123')

['1','2','3']

需要注意的地方

>>>t1=[1,2,3]

>>>t2=t1

>>>t2[0]=0

t2=[0,2,3]

>>>t1

t1=[0,2,3]        t1=t2是因为这两个指向了同一个列表

若想分成两个不相干的列表

t2=t1[:]        利用切片，这样就分成了两个互不干扰的列表

 

若想替换列表中的值，可利用如下形式

>>>t=[1,2,3,4,5,6,7,8,9,10]

>>>t[2:4]=[10:20]

t=[1,2,10,20,5,6,7,8,9,10]

 若想多加列表中的值，可利用如下形式

>>>t=[1,2,3,4,5,6,7,8,9,10]

>>>t[2:4]=[10:20:30]

t=[1,2,10,20,30,5,6,7,8,9,10]        就会在列表里多加一个位置存放多出的一个数

若想删除列表中的值，可利用如下形式

一、

>>>t=[1,2,3,4,5,6,7,8,9,10]

>>>t[2:4]=[:]

t=[1,2,5,6,7,8,9,10]

二、

del:将某一位置的字符删除

例

>>>del t[2]

t=[1,2,4,5,6,7,8,9,10]

 

列表的函数

append():在列表后面增加一个数

例

>>>t1=[1,2,3]

>>>t1.append(5)

>>>t1

[1,2,3,5]

extend():在列表后面增加一串数

>>>t1.extend([5,6,7])

>>>t1

[1,2,3,5,6,7]

insert():在列表中插入一个数

例

>>>t1.insert(1,9)        insert(某个位置前，插入某个数)

>>>t1

[1,9,2,3]

>>>t1.insert(100,-1)

>>>t1

[1,9,2,3,-1]        若超出列表范围，则默认加在列表末尾

 

remove()：删除指定大小的那个数

>>>t1.remove(1)

>>>t1

[9,2,3,-1]

pop():可以拿掉列表中最后的元素，也可将其弹出

例

>>>t1.pop()

>>>t1

[9,2,3]

>>>print(t1.pop())

-1

>>>print(t1.pop(2))

3

reverse()：颠倒列表中所有元素的顺序

>>>t1.reverse()

>>>t1

[3,2,9]

index():查找函数所在位置

>>>print(t1.index(9))

2 

split()：利用指定内容作分格

例

>>>s='this is a test'

>>>s.split()

['this','is','a','test']

>>>s1='12:35'

>>>s1.split(':')

['12','35']

>>>s2='12::35'

>>>s2.split(':')

['12',' ','35']

join()：将列表的各个元素组成一个字符串

例

>>>s='this is a test'

>>>t=s.split()

>>>t

['this','is','a','test']

>>>' '.join(t)        连接的东西.join()

'this is a test'

 

元组

元组和列表没有实质性的区别。元组为圆括号()，列表为方括号[]

元组里的内容不可修改

例

>>>t=[1,2,3]

>>>t[0]=0

>>>t

[0,2,3]

>>>p=(1,2,3)

>>>p[0]=0

error

tuple()：将方括号转变为圆括号

>>>p=tuple(t)

>>>p

(0,2,3) 

如果有用逗号分割的量，那就会被系统默认成元组

>>>a,b=3,4

>>>a

3

>>>b

4

>>>(a,b)=(3,4)

>>>a

3

>>>

4 

sort():将打乱的数字循序进行有序排列

>>>t=[4,5,7,1,2,3]

>>>t.sort()

>>>t

[1,2,3,4,5,7]

使用sort函数对列表降序排序

        旧列表.sort(reverse = True)        

        sort函数用法：

        列表名.sort(reverse = False)  其中，reverse = True 降序， reverse = False 升序（默认）   

 

随机库函数random

shuffle():将一组数据打乱且是随机的

例

>>>random.shuffle(t)

[2,5,7,3,1,4]

choice():从列表中随机选出一个元素

>>>random.choice(t)

2

 

random.random()：随机产生一个0-1之间的浮点数

random.randint(1,100)：随机产生一个1-100的整数

 

>>>random.seed(0)

>>>random.randint(1,100)

50

>>>random.randint(1,100)

98

>>>random.seed(0)

>>>random.randint(1,100)

50

>>>random.randint(1,100)

98

seed()：产生随机数种子的函数，但根据上述显示并不完全“随机” ，是由一个计算公式得到的，会根据上一次随机数的值来计算下一个随机数

所以如果给了一个确定的seed()，那下一次永远是一个确定的值

seed()可以用来做测试，保证相同的序列

 

条件语句

if        条件:

        想要执行的语句        有缩进代表这条语句是从属上面的

else:

        想要执行的语句

 

else和if组成的新函数elif

                                                                  | 

 

if 条件：

        执行语句

elif 条件:

        执行语句

else:

        执行语句

 

循环语句

while Ture(也可以是循环条件):

        执行语句1

        执行语句2

                .

                .

break:跳出循环

新手写while语句时，先不着急写循环条件，先写循环内部要执行的语句

for 元素 in range():

        执行语句

for循环也可以和else进行连用

例：判断两个数之间的数是否为素数，并将其相加

m,n=map(int,input().split)

sum=0

count=0

for x in range(m,n+1):

        for k in range(2,x):

                x%k==0

                break

        else:

                count+=1

                sum+=x

print(count,s)

 

range()：产生数列的函数        用法在笔记开始部分

代码异常

x=int(input())

t=[1,2,3,4,5]

try:

        print(t[x])

except:

        print('x is not a valid index')       代码不会结束，不会报错，如果输入的x不再t的列表范围内，则会进入except执行print输出语句

 

新语句

else：当没有发生异常所执行的语句

finally：是否异常最后都要执行的语句

x=int(input())

t=[1,2,3,4,5]

try:

        print(t[x])

        print('hello')        检测是否做了try语句

except:

        print('x is not a valid index')

else:

        print('nothing')

finally:

        print('anyway')

 

一、若x在范围内，则执行try→else→finally

二、若x不在范围内，则执行except→finally

 

集合

{}表示

>>>s={1,2,3,3,4}

>>>s

{1,2,3,4}        唯一性

>>>s={1,2,4,5,3}

>>>s

{1,2,3,4,5}

add()：向集合里添加一个数，并进行排序

>>>s.add(0)

{0,1,2,3,4,5}

集合是无序的

set()：将列表转为一个集合，也可表示空集

>>>t=[1,2,4,5,3]

>>>s1=set(t)

>>>s1

{1,2,4,5,3}

集合的对象不能取下标，因为不能指定位置

>>>s1[0]

error

 

>>>s2={2,4,6,8}

>>>s1|s2        |符号为并集

{1,2,3,4,5,6,8}

>>>s1&s2        &为交集

{2,4}

>>>s1^s2        对称差（做完并集减去交集）

{1,3,5,6,8}

>>>s1-s2        相减,只留下s1的元素

{1,3,5}

 

字典        

dict()：将内容变成一个字典

>>>d={'one':1,'two':2}        'one'称为键(key)

>>>d

{'one':1,'two':2}

>>>d['one']

1

>>>d['two']

2

若字典里要找其他东西，但改东西不存在时，可直接赋值

>>>d['three']=3

>>>d['three']

3

 

字典的基本运算

删除条目

del()语句，删除指定条目

del score['张三']

注：如果指定键不存在，则会抛出keyError异常

>>>d={'one':1,'three':3}

>>>for name in d:

        print(d[name])        内容

1

3

>>>for name in d:

        print(name)        键

one

three

 如果原本就在字典里，可以重新赋值修改

>>>d['name']=值

len()：在字典里可计算条目个数

min()：在字典里找到长度最小的key（键）

max()：在字典里找到长度最大的键

sum()：不可在字典中执行，因为key是字符串

get()：找到指定的键的值

>>>d.get('one')

1

如果

>>>d.get('ok')

                因为key不存在

>>>d.get('ok',0)

0        如果不存在则为0

 

函数

 自定义一个函数

def 函数名(参数表):

        函数体

 

 lambda用来编写简单的函数

def用来处理更强大任务的函数

 

sin（）：是一个math函数库里的自带函数，使用时要输入import

练习：定义函数y=sin(x)+1

>>>import.math

>>>def f(x):

>>>        y=math.sin(x)+1

>>>        return y

>>>y=f(3.5)

>>>print(y)

y的结果

函数参数

 

print(dis(1,3,4,5))里的1，3，4，5为位置参数

 

 x1=1,y2=5为关键字参数

 

要注意先写位置参数再写关键词参数！！！

 

星号*将一组可变数量的位置参数集合成参数值的元组

a分别给到3和5        b分别给到(7,9)和(8,1,6,89)

 

 **两个星号表示收集参数到字典中

 

 

 

 

*在列表前面，将其中实参拆出来

 

 可变对象和不可变对象当参数时，效果可能不同

当实参是不可变对象时，形参值改变不会影响实参

当实参是可变对象时，形参值改变可能会影响实参

例

 函数的返回值

概念

 

局部变量与全局变量

python中赋值即定义

当局部变量与全局变量同名

例

def scope():

        var1=1        局部变量

        print('函数内部打印结果')

        print(var1,var2)

var1=10        全局变量

var2=20        全局变量

scope()

print('函数外部打印结果')

print(var1,var2)

 如希望在函数中使用全局变量，而不是创建局部变量，就用global关键字声明

def scope():

        global var1        声明var1接下来为全局变量

        var1=1        局部变量

        print('函数内部打印结果')

        print(var1,var2)        结果1，20

var1=10        全局变量

var2=20        全局变量

scope()

print('函数外部打印结果')        结果1，20        因为前面已经声明var=1了

print(var1,var2)

案例

x=100

def f():

        y=x        全局变量不关局部的事，这里没有定义局部变量x的值，于是出现错误

        x=0

        print(x)

f()

 递归

递归需要终止条件和递归条件

终止条件不满足时，递归前进

条件满足时，递归返回 

编写递归函数时，必须告诉它何时停止递归，从而避免形成无限循环

 

 

例题

 内置函数

 

例

 >>>students=[('江幸',89,15),('方鹏',80,14),('陈可',85,14)]

>>>print(sorted(students.key=lambda s:s[2]))        按年龄从小到大排序

[('方鹏',80,14),('陈可',85,14),('江幸',89,15)]

>>>print(sorted(students.key=lambda s:s[1),reverse=Ture)        按成绩从大到小降序 

map函数

 

举例 

zip函数

举例

字典键值互换

>>>d={'blue':500,'red':100,'white':300}        值不同

>>>d1=dict(zip(d.values(),d.keys())

>>>print(d1)

{500:'bule',100:'red',300:'white'}

eval和exec函数 

 举例

eval的作用就是将'x+3*y-4'的引号去掉，直接执行里面的语句

exec的作用就是将“hello world"的引号去掉，直接执行里面的语句

all和any函数 

举例

[]和0都代表False

程序结构

import 模块名

模块名是另外一个python文件的文件名，不包含扩展名，模块是可以运行的程序

”import 模块名"就是执行文件名为模块名的程序

引入模块中函数的另一种方法

from 模块名 import *

直接引入所有函数，调用时不需要再加模块名

from 模块名 import 函数名

引入模块中单个函数，调用时也不需要再加模块名

模块名字空间

dir(模块名)：显示模块内容

包

包是一个目录，包含一组模块文件和一个init.py文件

import 包名.模块名        导入包中模块

包名.模块名.函数        调用函数 

 

sys模块 

常用量 

sys函数的返回值是字符串，如果要返回整数，前面需要加int()

 

例

 

文件读写操作

计算机文件：是储存在某种长期储存设备上的一段数据流

类型：二进制文件和文本文件

图形文件及文字处理程序等计算机程序都属于二进制文件

文本文件是可以用文字处理程序阅读的简单文本文件

读写步骤：

1.打开文件        2.处理数据        3.关闭文件

readline():读取文件内容返回字符中

 

显示文件内容：

有一个记事本为"7-1.txt"

textFile=open("7-1.txt","rt")        以文本方式打开

t=textFile.readline()        读取文本内容

print(t)

textFile.close        将文本关闭

binFile=open("7-1.txt","rb")        以二进制方式打开

b=binFile.readline()

print(b)

binFile.close()

open函数

 

文件打开模式 

文件读写函数

例子

多行文件读写

用readlines()读写多行文件

f=open("score.txt","r")

for line in f.readlines():

                print(line)        处理行

f.close()

可用嵌套列表存放多行内容

 

例子

 

 

 

输入输出重定向