python从入门到实践

变量和简单的数据类型

变量

a="hello world"

变量的命名和使用

变量名只能包含字母,数字和下划线.不能包含空格不能讲python关键字和函数名字作为变量

字符串

str="ma benteng"

字符串的方法

· str.title()

首字母大写标题函数

· str.upper()

字符串全部大写

· str.lower()

字符串全部小写

· 拼接字符串用+操作符

+进行连接, 像js

· \n换行\t制表符

print("\n nihk\t111")

· str.rstrip()过滤空格三个函数

删除末尾的空白

str.rstrip()过滤左边的空格str.strip()过滤两边的空格

· str.split()

将字符串以空格分隔

数字

数字类型

整数

2+2

浮点数

0.1+0.1结果可能是不确定的0.2000000001

使用str()函数转换成字符串

str(2)

字符串和数值不能用+连接符进行连接,否则会报错.

注释

单行注释

#这里是注释

多行注释

"""1111"""或者'''4545454'''

列表简介

list=[x, y, z]方括号的内容.可修改

访问列表元素

就可以访问第一个元素, print(list[0].end="")

访问列表最后一个元素[-1]

list[-1]返回最后一个元素

修改.添加和删除元素

修改列表元素

list[0]=xx就可以直接修改了

添加列表元素

list.append和insert函数

· 在列表末尾添加元素

list.append("k")

· 在指定位置插入元素

list.insert(2.'lp')在第三个位置插入字符串

删除列表中的元素

del list[0]删除第一个元素

· del list[1]一般删除

删除指定元素

· pop()删除元素并接着返回值

a=list.pop(索引值)删除并返回值.无索引默认最后一个

· 根据值remove()删除元素

a=list.remove("x")删除x的元素并返回

注意如果list.remove("x")的x元素有很多重复的话,只会删除第一个指定的值

组织排序列表

sort()对列表进行永久性排序

list.sort()会按字母对元素永久排序

在sort方法传递参数reverse=True,可以倒序

sorted()对列表进行临时排序

list.sorted()临时排序.再访问list列表还是之前的顺序

reverse()不排序只是倒着输出列表

list.reverse()会倒着输出list列表的元素

确定列表的长度

len(list)可以获取list列表的个数

操作列表

列表可以修改.元组不能修改

遍历整个列表

for line in list:print(line)

lists=[x,y,z]for line in lists:print(line)print("结束了")#这里没有缩略所以没有循环了python根据缩进来判断代码行与前一个代码行的关系.要注意缩进可能导致的错误

创建数值列表

list=[1.2.3.4]或者list(range(1.5))

for num in range(1.5)函数

函数是生成一系列的数值(还不是列表.不过可以循环了)

使用range(6)创建数值列表

list(range(1.3))

list(range(1.7.2))最后一个参数是步长2输出[1.3.5]a=5a**2表示a的平方等于25

对数字列表执行统计计算

· 最小值min(list)

· 最大值max(list)

· 总和sum(list)

列表解析(一行代码就可以生成列表)

list=[value**2 for value in range(1.11)]

使用列表的一部分数据[分割范围]

对列表进行切片

list[0:3]输出0.1.2前三个元素的列表

list[1:4]输出1.2.3三个元素的列表

list[:3]输出0.1.2前三个元素的列表

list[2:]输出从第三个到最后的所有元素的列表

list[-3:]输出最后三个元素的列表

遍历列表的切片

for line in list[:3]:遍历前三个元素

复制列表list=[1.2.3]

a=list[:]是复制.a=list就不行会指向同一个地址

元组tuple=(50.100.150)

访问tuple[0]第一个元组

遍历元组中的所有值

for line in tuple:print(line)

元组其中不能改.但是可以覆盖

tuple[0]不能改.不过可以覆盖tuple=(1.2.23)

代码规范

python关心水平缩进.但是不注重垂直间距.所以有很多空行也没问题.

if语句

if a==3:缩进

一个简单的示例

cars=["audi","bmw",'toyata']for car in cars:if car=='bmw':print(car.upper())else:print(car.title())还有elif相当于elseif

条件测试

检查字符串是否相等考虑大小写

大小写敏感

检查是否不相等

if a!=3:

比较数字>=!=

if a>=2:

检查多个条件and和or

if a>20 and a<50:

为了改善可读性,可将每个测试都分别放在一对括号内(a>3) and (b<5)或者用or或a>5 or a==5

检查特定值是否不包含在列表中

if "x" not in lists:判断x是否在列表元素中

if语句

if 条件:缩进语句

可用多个条件a=8if a>10:print("大于10")elif a<6:print("小于6")elif a>100:print("大于100")else:print("以上条件都不符合")if语句上面如果第一个条件满足的话,之后的语句将不被执行直接跳过了.如果你只想执行一个代码块,就使用if-elif-else结构,如果要运行多个if代码块,就使用一系列独立的if语句.if list:这里可以判断如果列表有元素非空就执行可以编写编码if a<4:写成if a < 4:中间加个空格更清晰一点.

字典dict={'key':'value\'}

字典就是以{}包括的key-value键值对

一个简单的字典

一些外星人,这些外星人敌人的颜色和点数各不相同alien_0={'color':'green','points':5}print(alien_0['color'])#访问alien_0字典的color键字典就是一系列的键值对,每个键都和一个值相关联,可以用键来访问与之对应的值.值可以是数字,字符串,列表,字典.

访问字典中的值

dict[key]

添加键值对

dict['money']=9999

修改字典中的值

dict[key]=value222

删除键值对

del dict['money']

遍历字典(不加方法默认遍历key)

for key.value in dict.items():

遍历所有的键值对dict.items()

for key.value in dict.items():, 顺序可能不对的

注意遍历键值对不能用dict[0]来访问,用dict[key],0也可以访问,可能不是我们要的值

[默认方式]遍历字典的所有键(乱序)

for key in dict.keys()

按顺序遍历字典中的所有键(key排序)

for name in sorted(dict.keys())

遍历字典中的所有值

for value in dict.values()

遍历字典中不重复的所有值[不重复]

for value in set(dict.values()):

嵌套--字典放在列表中

aliens=[{key:value}, {key1:value1}]

字典列表

alien_0={'color':'green','points':5}alien_1={'color':'yellow','points':5}alien_2={'color':'red','points':5}aliens=[alien_0,alien_1,alien_2]for alien in aliens:#默认遍历所有键print(alien)keys()方法并非只能用在遍历,实际他返回一个列表,可以用in方法判断存在不if 'x' not in dict.keys():

在字典中储存列表

{key:[1.2.3]}值是一个列表

在字典中储存字典

{key:{'key2':value.key21:value21}}

用户输入和while循环

函数input()的工作原理

message=input("请输入你的名字")

int()来获取数值输入

int("22")将输入的字符串22转换成数值

求模运算符(余数)

4%3得出余数1

while循环

a=1;while a<10:print(a)--a+=1

可以在while循环不断的运行,但也要定义一个退出值,一单用户输入quit就退出..就这个意思

while循环使用变量标志

active=True

在复杂的程序中,很多不同的事件都会导致程序运行,比如万星人一个飞船都没有了,或者城堡都没有了,就要结束,这时候定义变量文本或者数值就显得不合适了,就while判断active的值是否True,如果是就运行,如果某个事件触发成false了就停止运行.

使用break退出循环

在某个条件跳出循环继续执行下面语句

在循环总使用continue

不跳出循环继续下一次循环

避免bug造成无限循环.

使用while循环来处理列表和字典

for循环是遍历列表的有效方式,但是for循环不适合修改列表,否则将导致python难以跟踪其中的元素,因为没有key?要遍历列表的同时还要对其进行修改应该使用while循环.

while遍历列表不用in.直接写lists

while lists:

lists=[1,2,3,4,5,6,7]list11=[]while lists:currentuser=lists.pop()list11.append(currentuser)print(list11)注意用while lists:的时候里面一定要删除移动处理,不然里面一直有值会造成无限循环的

删除包含特定值的所有列表元素list.remove('value')

删除列表重复元素while 'cat' in pets:--pets.remove('cat')

pets=[dog,cat,rabbit,cat,fish]while 'cat' in pets:pets.remove('cat')

使用用户输入来填充字典

用while循环input函数来填充key和value.还有一个变量提示是否添加退出False

定义函数def name():

向函数传递参数

def name('xing'):之后里面调用

也可以传递修改列表

name(lists)返回修改后的好多人列表

禁止修改函数修改列表

name(lists[:])这里就表示传递的是副本lists列表不受影响

避免实参错误

执行函数对应的参数不能不匹配否则报错

返回值

函数执行不一定要输出.可以返回内容

可以返回简单的字符串,数值,也可以返回字典等数据定义函数可以结合使用while和for等使用,这里面向新手了,自己理解,可以自己根据需要定义功能.

传递任意数量的实参

def name(*mings)传递多个就print多个pg.130

传递多个里面可以用for循环来处理,就算是一个也可以很好处理for ming in mings:print(ming)同理,也可以传递一个位置实参,之后传递一个任意数量实参只要函数定义像上面定义好处理过程就ok,还有任意数量的关键字实参,具体在pg131

实参和形参

上面xing是形参.执行函数真实的value是实参

传递实参

位置实参

按位置调用def name(ming.xing):真实调用name(teng.ma)一一对应

· 函数可以不同的实参调用很多次

· 位置实参的顺序很重要

必须一一对应.第一个是名.第二个是姓

关键字实参

传递给函数名称--值对name(ming=teng.xing=ma)

形参默认值

def name(xing="ma")执行没有参数就是ma

将函数储存在模块总

用import导入写函数的文件就ok

导入整个模块(在test.py中)

import test调用函数test.name()就ok

只导入特定的函数

from test import name调用函数直接name()就ok

使用as给函数指定别名.防止命名冲突

from test import name as ming调用函数直接ming()

使用as给模块指定别名

import test as diy调用函数就diy.name()

导入模块中的所有函数[不推荐不了解的文件]

from test import *

不太推荐这样的方法导入,因为可能函数太多自己不了解而和自己写的函数有命名冲突了,最好直接导入模块使用句点表示法来调用或者直接导入单个模块或者函数

类

面向对象编程

创建和使用类

创建Dog类

· 先class Dog():

类首字母大写.这里的括号是继承用的

· 再def __init__(self.name.age):

类方法必须第一个形参是self自身.其他供实例化后其他方法调用

· 然后定义自己的方法

def sit(self)第一个参数必须是self

注意self为前缀的变量都可供类中的所有方法使用

根据类创建实例

mydog=Dog('huahua'.6)

· 访问属性

mydog.name

· 调用方法

mydog.sit(self)如果需要第二个之后也可以传递参数的

· 可以创建无数的实例

yourdog=Dog('gouwa'.6)

使用类和实例

· 创建类

这里基本和上面一样,先class 首字母大写():然后先def __init__(self,参数,参数):self.参数="4142"然后定义自己的方法再调用上面的形参

· 给属性指定默认值

self.other=0不用传递是类初始的值

· 修改属性的值

o 直接修改属性的值

实例化之后mydog.age=7

o 通过方法修改属性的值

mydog.updateage(7)

方法执行不用self但是定义的时候第一个参数一定是self

o 通过方法递增属性的值

不是传递直接改变.是加上传入的值

这个知识点没有必要,可能是对新手的一种介绍,自己可以按需调整,也巩固知识,只是不是必须的.

继承类

之类的方法__init__()先处理初始化父类传递参数

一般这里要处理传入参数给父类用

class Dcar(Car):def __init__(self,make,model,year):#子类先处理参数给父类"""初始化父类的属性"""super().__init__(make,model,year)#这里调用父类的init初始化方法

给子类定义属性和方法

在本类init定义属性在其他函数定义方法

导入类

从其他文件导入类

导入单个类

from car import Car从cat.py导入Car类

一个py文件可以写很多类.导入逗号分隔

from car import Car.Dcar

导入整个模块

import car实例化类用car.Car('auto'.2016)

导入模块所有类

同之前介绍的.不推荐这样from car from *

在一个模块导入另外一个模块

导入car.在car中也可以它导入其他的.都可以用

python 标准库

collections中的OrderedDict类可以字典排序不乱

介绍了字典如果不想乱序可以用这个类,在page159

类编码风格

一般使用驼峰命名法

class UserName():

每个类包含一个注释'''用来说明功能'''

方法也可以写功能之前先注释

建议一行分隔方法

两行来分隔类.垂直显得好看

文件和异常

处理文件/处理异常/json

从文件中读取数据

with open(xx) as f:

读取整个文件

with open('11.txt') as f:

with open('11.txt') as f:contents=f.read()print(contents)

· 先with关键字可以自动关闭流

注意是with不是while循环啊老铁

· open()访问文件内容第一步先打开

返回一个表示文件的对象

· read()读取文件的全部内容

文件路径

linux/在window是\

open(111.txt)打开11.txt文件的时候会在当前执行的py文件(py程序)所在的目录中查找文件,也可以直接放文件的绝对路径.

逐行读取

在with open(1.txt) as f:之后for line in f

file="111.txt"with open(file) as f:for line in f:print(line)这里就是逐行读取了,就不用read()方法了注意print()会自动换行的,如果不需要可以line.rstrip()过滤

file.readlines()

读取所有行并返回列表

if "x" in "xjhfdkdejak"会返回true的

这里记一个知识点

写入文件

· 写入空文件

with open(11.txt.'w') as f:--f.write('hello')

· 写入多行

还是上面多写几个f.write(str)或者循环换行加\n

· 附加到文件open(1.txt.'a')

先with open a方式再f.write就ok

异常

try:----except:pass语句

处理ZeroDivisionError异常

try:---except ZeroDivisionError:捕获这个错误

使用else代码块

try:--except:----else:---

储存数据

模块json

使用json.dump()和json.load()

需要先import json库

· json.dump(lists.f)

将py列表保存到f的json文件中

import jsonnumbers=[2,3,4,6,1,8,7]filename='lists.json'with open(filename.'w') as f:json.dump(numbers,f)将列表保存到lists.json文件中

· list:json.load(f)

读取f.json文件并保存

测试代码

使用unittest模块来测试代码pg188

8