《python从入门到实战》学习笔记

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/tuyi5078/article/details/82900274

《python从入门到实践》

 

目录

《python从入门到实践》

1、字符串

2、数字

3、注释器

4、python之禅

5、列表

6、操作列表

7、元组

8、if语句

9、字典

10、用户输入

11、while循环

12、函数

13、类

14、文件和异常

15、测试代码


1、字符串

①title方法(方法是python对数据执行的操作。一般方法后面都需要接一对括号,因为方法都需要额外信息,如果没有额外信息,则接空括号)是以首字母大写,其他字母小写的方式来显示字符串中的每一个单词。

name="ada ADA aDA Ada"
print(name)

输出结果:

②upper方法,将字符串的每一个字母改成大写

③lower方法,将字符串的每一个字母改成小写

④使用加号(“+”)来连接字符串

⑤要在字符串中添加制表符,可使用字符组合\t ;要在字符串中添加换行符,可使用字符组合\n

name="python\n\thello\nworld"
print(name)

输出结果:

⑥strip()方法用于删除字符串开头和结尾的空格,lstrip()方法用于删除字符串开头的空格,rstrip()方法用于删除字符串结尾的空格。

2、数字

①**表示乘方

②浮点数的运算结果,小数的位数可能是不确定的

③在python2中,整数之间的除法得到的结果只会是整数,结果会将小数部分直接舍去。比如,3/2,返回结果为1。为了避免这种情况(想要得到的结果是真实浮点数值),输入时务必确保有一个操作数为浮点数。

3、注释器

在python中使用#来注释文本

4、python之禅

import this

5、列表

列表是一组有顺序的元素的组合。bi['a','b','c']

①列表使用一组中括号表示([ ]),用逗号来分隔其中的元素

②访问列表元素,使用列表名加索引,索引从0开始;访问列表最后一个元素,可以用索引(-1)

③添加元素:(1)append()方法:在表尾添加元素,如:bi.append('d')

                      (2)insert()方法:加上索引在列表任何位置添加元素,如:bi,insert(0,'A'),则0号元素就为A。

                          insert方法插入元素时需要写入索引位置信息,插入的新元素即在写入时的索引位置。

④删除元素:(1)pop()方法:在表尾删除元素,如:bi.pop()

                      (2)del方法:加上索引信息,删除在列表中任一位置的元素,如:del bi[0]

                      (3)实际上也可以使用pop()方法来删除列表中的任一位置的元素,只需要在pop方法的括号中加入元素索引信息即                               可。如:bi.pop(0)

                      (4)remove方法:当不知道删除元素的索引时,只知道删除元素的内容,就可以用remove(),remove()方法每一次                             只能删除列表中第一个为该元素的值,若想要全部删除该元素,需要使用循环语句。 

注意:del方法没有返回值,而pop方法有返回值。如果你不确定该使用del 语句还是pop() 方法,下面是一个简单的判断标准:如果你要从列表中删除一个元素,且不再以任何方式使用它,就使用del 语句;如果你要在删除元 素后还能继续使用它,就使用方法pop() 。

⑤组织列表(列表排序):(1).sort()方法:对列表按Ascii码进行永久性的排列(升序(数字在前,字母在后;大写字母在前,小                                                    写字母在后));若要逆序,则只需要向sort方法传递参数reverse=True,即sort(reverse = True)

                                           (2)sorted()方法:对列表进行临时性升序排序,不改变原列表值。该方法的调用不是使用点方法来调                                                   用,而是直接将列表名作为参数传递给sorted方法,如:sorted(bi);若要逆序则使用                                                                       sorted(bi,reverse=True)

                                            (3).reverse()方法:永久性直接对列表元素逆序排序

⑥获取列表长度:len()方法,如:len(bi)

6、操作列表

①循环列表:使用for循环遍历整个列表:可以使用临时变量存储列表中的每一个值。列如:

bis=['asfas','asfdas''er','dfg','wer',2]
for bi in bis:
    print(str(bi)+' is bis')

输出结果:

②在for循环中,可对每个元素进行任何操作,如:

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(magician.title() + ", that was a great trick!")     
    print("I can't wait to see your next trick, " + magician.title() + ".\n")

输出结果:

③使用range()函数产生一串数字,如

for num in range(1,9,2):
    print num

输出结果:

range函数的前两个参数表示,所要输出数字的范围,此范围不包括最后一个参数值,如上面的例子,所要输出的数字范围即为1到8。函数的第三个参数表示步长,也就是输出数字串的间隔,上面的例子就表示以间隔为2,输出1到9之间的数字。

④使用range()函数创建数字列表:结合list()方法,可以创建一个数字列表,range函数作为list方法的参数,如:

bis = list(range(1,9,2))
print(bis)

输出结果:

使用range函数几乎可以创建任意一个数字列表(思想:首先创建一个空列表,然后通过range方法创建数字,并不断的添加到列表中),如创建一个列表,其中包含前10个整数(即1~10)的平方:

squares = []
for num in range(1,11):
    squares.append(num ** 2)
print(squares)

输出结果:

⑤对数字列表进行简单的统计:

(1)求数字列表最大最小值:max()函数和min()函数,如min(bi)

(2)求数字列表的数字总和:sum()函数,如sum(bi)
 

⑥列表解析:将for 循环和创建新元素的代码合并成一行,并自动 附加新元素。要使用这种语法,首先指定一个描述性的列表名,然后,指定一个左方括号,并定义一个表达式,用于生成你要存储到列表中的值,接下来,编写一个for 循环,用于给表达式提供值,再加上右方括号。如,上面输出1到10平方的列表可写成列表解析的形式:

squares = [num ** 2 for num in range(1,11)]

⑦列表切片:截取列表中的一部分。基本语法:列表名[第一个索引:第二个索引],其索引从0开始,截取结果不包括第二个索引      值,列表中的最后一个元素的索引为-1。如:

bis = ['0sf','1ert','2fg','3ret','4try']
print(bis[0:2])

输出结果:

如果省略第一个索引参数,则自动从列表的第一个元素开始切片;如果省略第二个参数,则自动索引到列表的最后一个元素。

⑧遍历切片:与遍历range()函数一样,只要把range()函数改成列表切片即可,如:

bis=list(range(1,21))
for bi in bis[:2]:
    print bi

输出结果:

⑨复制列表:即对一个列表进行从首到尾的列表切片:[:],如:

bi1=list(range(1,15))
bi2=bi1[:]
bi1.append('this is 1')
bi2.append('this is 2')
print bi1
print bi2

输出结果:

由上面的例子可以看出,通过列表切片的方式对列表进行赋值,列表实现复制,在对一个列表进行改变时,另一个列表并不会随之改动。

#错误做法:简单的将一个列表赋值给另一个新的列表,不使用列表切片的方式,如:

bi1=list(range(1,15))
bi2=bi1
bi1.append('this is 1')
bi2.append('this is 2')
print bi1
print bi2

输出结果:

由此我们可以看出,只是将两个列表进行简单的赋值后,bi1和bi2实际上都指向同一个列表,不论我们对哪一个列表进行操作,另一个列表也会随之改动。

7、元组

元组使用一组小括号进行标识,看起来和列表一样,但是列表元素是可以随意改变的,元组元素则为一组不可变的元素。可以使用索引来访问元组元素,方法、书写格式与列表一样。遍历元组的方法也是一样的,同样可以使用for循环。注:元组元素不可以使用索引的方式进行重新赋值,但可以给同样名称的元组进行重定义。

8、if语句

①检查元素:(1)python中使用“==”,“!=”来判断两个元素是否相等时,严格按照大小写的规则,若要避免大小写,可以使用                                  lower()函数或者upper()函数来对字符进行相应的转换。

                     (2)检查多个条件,则可以用and进行条件连接,为了改善代码的可读性,可以用小括号将每个条件分隔开来。关                              键字or 也能够让你检查多个条件,但只要至少有一个条件满足,就能通过整个测试。

                     (3)使用关键字“in”来检查特定的元素是否在列表中,使用“not in”来检查特定元素是否不在列表中。

                     (4)还可以使用布尔表达式来作为测试条件。

②if语句的结构:if-elif-else,一个代码块中可使用多个elif,作为递进条件判断;写在多个代码块中的平行条件判断可用多个if语     句。

③对列表操作for循环前先确定列表不为空:if 列表名:

9、字典

在Python中,字典 字典 是一系列键 键—值对 值对 。每个键 键 都与一个值相关联,你可以使用键来访问与之相关联的值。与键相关联的值可以是数字、字符串、列表乃至字典。事实上,可将 任何Python对象用作字典中的值。 在Python中,字典用放在花括号{} 中的一系列键—值对表示。键和值之间用冒号分隔,而键—值对之间用逗号分隔。如下所示,定义一个dic字典,并根据其键访问其值:

dic = {0:'as','two':'qw',3:"zx"}
print(dic[0])
print(dic['two'])

输出结果:

①字典是一种动态结构,可随时在其中添加键—值对。要添加键—值对,可依次指定字典名、用方括号括起的键和相关联的           值。如对上面的dic字典添加键值对:4-ui

dic[4]="ui"
print(dic)

 输出结果:
在这里,字典的输出会自动对值进行排序后输出。

②要修改字典中的值,可依次指定字典名、用方括号括起的键以及与该键相关联的新值。如对上方dic字典修改键值对4-ui为4-er

dic[4] = "er"
print(dic)

输出结果:

③删除键值对:对于字典中不再需要的信息,可使用del 语句将相应的键—值对彻底删除。使用del 语句时,必须指定字典名和       要删除的键。 如将上方dic字典的0-as键值对删除。

del dic[0]
print(dic)

输出结果:

④遍历字典

(1)遍历得到键和值:要编写用于遍历字典的for 循环,可声明两个变量,用于存储键—值对中的键和值。对于这两个变量,可使      用任何名称。for 语句的第二部分包含字典名和方法items(),它返回一个键—值对列表。接下来,for 循环依次将每个键—值        对存储到指定的两个变量中。如遍历上面的dic字典:

for key,value in dic.items():
    print("key:" + str(key))
    print("value:" + value)

输出结果:

注意这里的items()方法,该方法将字典里的键值对转换成一个键值对列表,如对上面的dic字典调用items()方法:

print(dic.items())

输出结果:

(2)遍历得到所有的键:对字典调用keys()方法,然后使用for循环遍历,如对上面的dic字典进行键遍历:

for key in dic.keys():
    print(key)

输出结果:

(3)按顺序遍历字典中的所有键:调用keys()方法取出所有的键后,在调用sort()方法,对所有的键进行排序,如:

favorite_languages = {'jen': 'python', 'sarah': 'c', 'edward': 'ruby', 'phil': 'python', }
for name in sorted(favorite_languages.keys()):
    print(name.title() + ", thank you for taking the poll.")

输出结果:

(4)遍历得到所有的值:对字典调用values()方法,然后使用for循环遍历,如对上面的dic字典进行值遍历:

for value in dic.values():
    print(value)

输出结果:

(5)通过上面的方法提取字典中的值,并没有考虑值的重复性,如果字典中的很多重复的值,使用values()方法后遍历会得到大量      重复的值,为剔除重复项,可使用set()集合,集合类似于列表,但每个元素都是独一无二的。如:

favorite_languages = {'jen': 'python', 'sarah': 'c', 'edward': 'ruby', 'phil': 'python', }
for value in set(favorite_languages.values()):
    print(value)

输出结果:

⑤嵌套:将字典存放在列表中、将列表存放在字典中、将字典存放在字典中......

(1)将字典存放在列表中:如:

lists = []
for num in range(1,3):
    dics={"name":"cheng","age":18,"sex":"f"}
    lists.append(dics)
print(lists)

输出结果:

(2)将列表存放在字典中:如:

dics = {"name":"cheng",
        "likes":["food","running","movie"],
        "age":18
        }
for like in dics["likes"]:
    print("cheng likes: " + like)

输出结果:

(3)将字典存放在字典中:如:

users = {
    'aeinstein': {
        'first': 'albert',
        'last': 'einstein',
        'location': 'princeton',
         },
    'mcurie': {
        'first': 'marie',
        'last': 'curie',
        'location': 'paris',
        },
    }
for use,info in users.items():
    print("use is:" + use)
    print("fullname is :" + info["first"] +" " + info["last"])
    print("location is:" + info["location"])

输出结果:

10、用户输入

①input()函数:暂停程序,等待用户输入一些文本。获取用户输入后,python将其存储在一个变量中,以方便使用。

   在python2.7中,对input()的输入严格按照python的规则来,也就是说,若输入为字符串,则需要给输入加引号。如:

num = input("请输入一个数: ")
if num % 10 == 0:
    print(str(num) + "是10的倍数")
else:
    print(str(num) + "不是10的倍数")

输出结果:

②raw_input()函数:该函数作用与input()函数一样,都是完成用户的输入,但raw_input()函数的输入不用严格按照python规           则,也就是说若输入为字符串,则直接输入就行,不用添加引号,但raw_input()函数将所有的输入都当做是字符,也就是           说,如果输入为数字,并且在之后的操作中要将此输入作为数字使用,则还需要使用int()函数做强制字符转换。如:

num = raw_input("请输入一个数: ")
if int(num) % 10 == 0:
    print(num + "是10的倍数")
else:
    print(num + "不是10的倍数")

输出结果:

11、while循环

for 循环用于针对集合中的每个元素都一个代码块,而while 循环不断地运行,直到指定的条件不满足为止。如:

prompt = "\nTell me something, and I will repeat it back to you:\nEnter 'quit' to end the program."
message = ""
while message != 'quit':
    message = raw_input(prompt)
    if message != 'quit':
        print(message)

 输出结果:

①使用标志作为循环判断条件:只要标志为True则继续执行代码,否则停止循环。如:

prompt = "\nTell me something, and I will repeat it back to you:\nEnter 'quit' to end the program."
message = True
while message :
    message = raw_input(prompt)
    if message == 'quit':
        message = False
    else:
        print(message)

输出结果:

②使用break退出循环:要立即退出while 循环,不再运行循环中余下的代码,也不管条件测试的结果如何,可使用break 语           句。break 语句用于控制程序流程,可使用它来控制哪些代码行将执行, 哪些代码行不执行,从而让程序按你的要求执行你       要执行的代码。 

#coding=utf-8
prompt = "\nTell me something, and I will repeat it back to you:\nEnter 'quit' to end the program."
message = True
while message :
    message = raw_input(prompt)
    if message == 'quit':
        break
    else:
        print(message)

③使用continue退出当前一次循环,但不退出整个循环:要返回到循环开头,并根据条件测试结果决定是否继续执行循环,可使用continue 语句,它不像break 语句那样不再执行余下的代码并退出整个循环。如:

num = 0
while num < 5:
    num += 1
    if num % 2 == 0:
        continue
    print(num)

输出结果:

(2)删除包含特定值的所有列表元素(使用remove()方法可以删除列表中的一个特定元素),如:

yanzheng = ["lu","cheng","wei","liang","lu"]
while "lu" in yanzheng:
    yanzheng.remove("lu")
print(yanzheng)

输出结果:

(3)使用用户输入来填充字典

responses ={}
answer = True
while answer:
    name = raw_input("请输入你的名字:")
    response = raw_input("请输入你的答案:")
    responses[name] = response
    again = raw_input("请问是否愿意继续回答:(yes/no)")
    if again == "no":
        answer = False
for name,response in responses.items():
    print("调查者名字是:" + name)
    print("调查者回答是:" + response)

输出结果:

12、函数

①定义函数:使用关键字def 来告诉Python你要定义一个函数。这是函数定义 ,向Python指出了函数名,还可能在括号内指出函数为完成其任务需要什么样的信息。要使用这个函数,可调用它。函数调用 让Python执行函数的代码。要调用函数,可依次指定函数名以及用括号括起的必要信息。这里,在函数定义中用到的参数称为“形参”,在函数调用中用到的参数称为“实参”。

def hello(name):
    print("hello "+name)
name = raw_input("请输入你的名字:")
while name:
    hello(name)
    name = raw_input("请输入你的名字:")

输出结果:

②传递实参:

(1)位置实参:调用函数时,Python必须将函数调用中的每个实参都关联到函数定义中的一个形参。为此,最简单的关联方式是基于实参的顺序。这种关联方式被称为位置实参 。如:

def eating(time,food):
    print("现在是" + time +"点")
    print("现在要吃:" + food)
eating("9","mike")

输出结果:

(2)关键字实参:关键字实参 是传递给函数的名称—值对。你直接在实参中将名称和值关联起来了,因此向函数传递实参时不会混淆,关键字实参让 你无需考虑函数调用中的实参顺序,还清楚地指出了函数调用中各个值的用途。如:

def eating(time,food):
    print("现在是" + time +"点")
    print("现在要吃:" + food)
eating(food="mike",time = "9")

输出结果:

(3)默认值:编写函数时,可给每个形参指定默认值。在调用函数中给形参提供了实参时,Python将使用指定的实参值;否则,将使用形参的默认值。因此,给形参指定默认值后,可在函数调用中省略相应的实参。使用默认值可简化函数调用,还可清楚地指出函数的典型用法。 如:

def eating(time,food = "mike"):
    print("现在是" + time +"点")
    print("现在要吃:" + food)
eating(time = "9")
eating("12","apple")

输出结果:

③返回值:

(1)函数并非总是直接显示输出,相反,它可以处理一些数据,并返回一个或一组值。函数返回的值被称为返回值 。在函数中,可使用return 语句将值返回到调用函数的代码行。 返回值让你能够将程序的大部分繁重工作移到函数中去完成,从而简化主程序。 如:

def get_fullname(first,last):
    full_name = first + " " + last
    return  full_name
mom = get_fullname("wang","xia")
print(mom)

输出结果:

(2)实参可选:一个函数中可能包括多个参数,但是我们有时候并不一定在使用函数时都有这些参数,所以,可以使用默认值让参数变得可选,这样使用函数的人就只需在必要时才提供额外的信息。注意:在给形参赋予默认值时,一定要将赋予默认值的形参放在参数的最后,不然会出错。  如:

def get_formatted_name(first_name,middle_name="",last_name=""):
    if middle_name:
        full_name = first_name + ' ' + middle_name + ' ' + last_name
    else:
        full_name = first_name + ' ' + last_name
    return full_name.title()
musician = get_formatted_name('jimi', 'hendrix')
print(musician)
musician = get_formatted_name('john', 'lee','hooker')
print(musician)

输出结果:

 

④返回字典:函数可返回任何类型的值,包括列表和字典等较复杂的数据结构。如:

def full_name(first,last):
    full_info={}
    full_info["first_name"] = first
    full_info["last_name"] = last
    full_info["full_name"] = first + " " + last
    return full_info
ch=full_name("cheng","lu")
print(ch)

输出结果:

⑤结合使用while和函数,如:

def full_name(first,last):
    full_info={}
    full_info["first_name"] = first
    full_info["last_name"] = last
    full_info["full_name"] = first + " " + last
    return full_info
first = raw_input("请输入你的名:")
last = raw_input("请输入你的姓:")
while first != "q" and last != "q":
    ch = full_name(first,last)
    print(ch)
    first = raw_input("请输入你的名:")
    last = raw_input("请输入你的姓:")

输出结果:

⑥传递列表:向函数传递列表很有用,这种列表包含的可能是名字、数字或更复杂的对象(如字典)。将列表传递给函数后,函数就能直接访问其内容。当向一个函数传递一个列表时,可以多次执行该函数,其中的实参就为列表中的各个元素。如:

def full_name(name):
    full_info={}
    for first,last in name:
        full_info["first_name"] = first
        full_info["last_name"] = last
        full_info["full_name"] = first + " " + last
        print(full_info)
name = [("ceh","sdf"),("sd","er"),("we","io")]
full_name(name)

输出结果:

⑦在函数中修改列表:将列表传递给函数后,函数就可对其进行修改。在函数中对这个列表所做的任何修改都是永久性的,这让你能够高效地处理大量的数据。如:

ddef print_models(cons,kongs):
    while cons:
        con = cons.pop()
        print("请打印:" + con)
        kongs.append(con)
def ex_print(kongs):
    for kong in kongs:
        print("已经打印:" +kong)
cons = ["sd","sa","we"]
kongs = []
print_models(cons,kongs)
ex_print(reversed(kongs))
print("cons ="),
print(cons)

输出结果:

⑧禁止函数修改列表:有时候,需要禁止函数修改列表。为解决这个问题,可向函数传递列表的副本而不是原件;这样函数所做的任何修改都只影响副本,而丝毫不影响原件。将列表副本传递给函数,可以通过列表切片实现。切片表示法[:] 创建列表的副本。如:

def print_models(cons,kongs):
    while cons:
        con = cons.pop()
        print("请打印:" + con)
        kongs.append(con)
def ex_print(kongs):
    for kong in kongs:
        print("已经打印:" +kong)
cons = ["sd","sa","we"]
kongs = []
print_models(cons[:],kongs)
ex_print(reversed(kongs))
print("cons ="),
print(cons)

输出结果:

⑨传递任意数量的实参:通过在形参名前加星号(*)的方式创建一个空元组,在一个函数中,元组形参只能有一个,且元组形参必须放在最后。在函数定义时,需要通过for循环来取元组里的所有值。如:

def full_name(first,*lasts):
    for last in lasts:
        full = first + "" + last
        print("我姓:" + first)
        print("我名:" + last)
        print("我叫:" + full)
full_name("易","烊千玺","千岁","水")

输出结果:

如果要让函数接受不同类型的实参,必须在函数定义中将接纳任意数量实参的形参放在最后。Python先匹配位置实参和关键字实参,再将余下的实参都收集到最后一个形参中。 注,如上例中,形参名*lasts中的星号让python创建了一个名为lasts的空元组,并将收到所有的值都封装到这个元组中。

⑩使用任意数量的关键字实参,有时候,我们需要接受任意数量的实参,但预先不知道传递给函数的会是什么样的信息。这种情况下,课将函数编写成能够接受任意数量的键-值对——调用语句提供了多少就接受多少,在定义形参的时候,在形参前面加上两个星号,该形参就可以接收任意数量的实参。同样在定义函数时,要使用for循环来遍历键值对形参,特别的,在遍历这个形参时,要使用items()函数,将键值对转化成元组列表。如:

def info(pets,color,**cons):
    full_info = {}
    full_info["pet"] = pets
    full_info["color"] = color
    for key,value in cons.items():
        full_info[key] = value
    return full_info
dog = info("dog","white",location = "china",user = "qianxi",eat = "meet")
print(dog)

输出结果:

⑾将函数存储在模块中:函数的优点之一就是,使用它们可以将代码块与主程序分离。通过给定的函数名,可以让主程序容易理解得多。还可以进一步,将函数存储在被称为模块的独立文件中,再将模块导入主程序中。使用import语句允许子啊当前允许的程序文件中使用模块中的代码。通过将模块函数存储在独立的文件中,可隐藏程序代码中的细节,将重点放在程序的高层逻辑上。下面介绍导入模块的方法:

(1)导入整个模块:要让函数是可导入的,首先创建模块。模块是扩展名为.py的文件,包含要导入到程序中的代码。如:
创建一个make模块:

def make_car(producter,xinghao,**qitas):
    full_info = {}
    full_info["producter"] = producter
    full_info["xinghao"] = xinghao
    for key,value in qitas.items():
        full_info[key] = value
    return  full_info

接下来,在make.py所在的目录中创建另一个名为car.py的文件,在这个文件中导入上面创建的make模块:

import make
car = make.make_car('subaru', 'outback', color='blue', tow_package=True)
print(car)

代码行import make 让Python打开文件make.py,并将其中的所有函数都复制到这个程序中。你看不到复制的代码,因为这个程序运行时,Python在幕后复制这些代码。这就是一种导入方法:只需编写一条import 语句并在其中指定模块名,就可在程序中使用该模块中的所有函数。

(2)导入特定的函数,我们还可以导入模块中的特定函数,导入语法:from 模块名 import 函数名。通过用逗号分隔函数名,还可以根据需要从模块中导入任意数量的函数:from 模块名 import 函数名1,函数名2,函数名3。如:

from make import make_car
car = make_car('subaru', 'outback', color='blue', tow_package=True)
print(car)

(3)使用as给函数指定别名:如果要导入的函数名称与程序中现有的函数名称冲突,或者函数名太长,可以指定简短而独一无二的别名——函数的另一个名称。要给导入的函数起别名,需要在导入函数时就这样做,同样,可以给模块起别名。如:

from make import make_car as mc
car = mc('subaru', 'outback', color='blue', tow_package=True)
print(car)

(4)导入模块中所有的函数:from 模块名 import *

13、类

在面向对象的编程中,编写表示现实世界中的事物和情景的类,并基于这些类来创建对象。编写类时,定义一个大类对象都有的通用行为。基于类创建对象时,每个对象都自动具备这种通用行为,然后可以根据需要赋予每个对象独特的个性。根据类来创建对象被称为实例化。

①创建一个类:根据约定,在Python中,首字母大写的名称指的是类,在python2.7中创建类时,需要在括号内加上“object”(class Dogs(object))。如:

class Dogs(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def sit(self):
        print(self.name.title() + "is now sitting.")
    def roll_over(self):
        print(self.name.title() + "rolled over!")

(1)__init__()方法:

类中的函数统称为方法,__init__()方法是python中一个特殊的方法。在一个类中若包含__init__()方法,则每一次调用这个类创建新的实例时,python都会自动运行它。在这个方法中,self形参是必不可少的,而且必须放在所有形参的最前面。使用类来创建实例时,将自动传入实参self,每个与类相关的方法都自动调用实参self,它是一个指向实例本身的引用,让实例能够访问类中的属性和方法,每一次创建实例时调用方法,都不用给形参self赋值,它会自动赋值。以self为前缀的变量可供类中的所有方法使用,我们还可以通过类的实例来访问这些变量。这样可通过实例访问的变量称为属性。在上例中,Dog 类还定义了另外两个方法:sit() 和roll_over() ,由于这些方法不需要额外的信息,如名字或年龄,因此它们只有一个形参self 。

②根据类创建实例,如:

my_dog = Dogs('willie', 6)
my_dog.sit()
print("My dog's name is " + my_dog.name.title() + ".")
print("My dog is " + str(my_dog.age) + " years old.")

在这里创建了一个名为my_dog的实例,Python使用实参'willie' 和6 调用Dog 类 中的方法__init__()创建一个表示特定小狗的示例,并使用我们提供的值来设置属性name 和age。方法__init__() 并未显式地包含return 语句, 但Python自动返回一个表示这条小狗的实例。

(1)访问实例的属性和调用实例的方法都使用句点表示法。如:my_dog.name,my_dog.sit

(2)可以根据需求创建任意数量的实例

实例 用户 :创建一个名为User 的类,其中包含属性first_name 和last_name ,还有用户简介通常会存储的其他几个属性。在类User 中定义一个名 为describe_user() 的方法,它打印用户信息摘要;再定义一个名为greet_user() 的方法,它向用户发出个性化的问候。

class User():
    def __init__(self,first_name,last_name,**else_infos):
        self.first_name = first_name
        self.last_name = last_name
        self.infos = {}
        self.infos["first_name"] = self.first_name
        self.infos["last_name"] = self.last_name
        for key,value in else_infos.items():
            self.infos[key]= value
    def describe_user(self):
        for self.key,self.value in self.infos.items():
            print("users' " + self.key + " is " + self.value)
    def greet_user(self):
        print("hello " + self.first_name + "" + self.last_name)
chenglu = User("cheng","lu",age = "18",sex = "女")
chenglu.describe_user()
chenglu.greet_user()

输出结果:

③使用类和实例

(1)类中的每个属性都必须有初始值,哪怕这个值是0或空字符串,我们可以在__init__()方法中指定初始值,给属性设置一个默认值,这样就无需给这个初始值提供形参。如:

class User():
    def __init__(self,first_name,last_name):
        self.first_name = first_name
        self.last_name = last_name
        self.like = "mike"
    def user_like(self):
        print(self.first_name + self.last_name + " likes " + self.like)
chenglu = User("cheng","lu")
chenglu.user_like()

输出结果:

在这里给like属性赋予了一个默认的属性值“mike”

(2)直接修改属性值:要修改属性的值,最简单的方式是通过实例直接访问它。如对上例中的类做如下修改:

chenglu.like = "apple"
chenglu.user_like()

输出结果:

(3)通过方法修改属性值:在定义类的时候就在类里面定义一个修改属性值的方法。在定义一个实例时,若想改变实例的默认属性值,可以先调用修改属性的方法,再输出即可。如:

class User():
    def __init__(self,first_name,last_name):
        self.first_name = first_name
        self.last_name = last_name
        self.like = "mike"
    def update_like(self,up_like):
        if up_like == "mike":
            print("喜好未改变")
        else:
            self.like = up_like
    def user_like(self):
        print(self.first_name + self.last_name + " likes " + self.like)
chenglu = User("cheng","lu")
chenglu.update_like("banana")
chenglu.user_like()
chenglu.update_like("mike")

输出结果:

餐馆就餐人数实例:

class Restaurant():
    def __init__(self,restaurant_name,cuisine_type):
        self.restaurant_name = restaurant_name
        self.cuisine_type = cuisine_type
        self.number_served = 0
    def describe_restaurant(self):
        print("这家餐馆的名字是:" + self.restaurant_name)
        print("该餐厅属于: " + self.cuisine_type)
    def set_number_served(self,num):
        #cur_num = self.number_served + num
        if self.number_served + num > 50:
            print("就餐人数已达上限")
        else:
            self.number_served += num
    def open_restaurant(self):
        print("餐厅正常营业")
restaurant = Restaurant("家家","中式餐厅")
restaurant.number_served = 5
restaurant.set_number_served(10)
print("目前就餐人数为:" + str(restaurant.number_served))
restaurant.set_number_served(10)
print("目前就餐人数为:" + str(restaurant.number_served))
restaurant.set_number_served(10)
print("目前就餐人数为:" + str(restaurant.number_served))
restaurant.set_number_served(10)
print("目前就餐人数为:" + str(restaurant.number_served))
restaurant.set_number_served(10)
print("目前就餐人数为:" + str(restaurant.number_served))
restaurant.set_number_served(10)
print("目前就餐人数为:" + str(restaurant.number_served))

输出结果:

④继承:编写类时,并非总要从空白开始,如果你要编写的类是一个现成类的特殊模板,就可以使用继承。一个类继承另一个类时,它将自动获得另一个类的所有属性和方法,原有的类称为父类,新的类称为子类。子类继承了父类所有的属性和方法,同时还可以定义自己的属性和方法。

(1)子类的方法__init__()

创建子类实例时,python的首要任务是给父类中的所有属性赋值,在这里使用__init__()方法。如:

class Cars(object):
    def __init__(self,make,model,year):
        self.make = make
        self.model = model
        self.year = year
        self.oldmeter = 0
    def description (self):
        print("这个车的制造产商是:" + self.make  +" 这个车的模型是:" + self.model + " 这个车的生产年份是:" + self.year)
    def update_meter(self,meter):
        if self.oldmeter + meter > 50:
            print("此车里程数达到上限")
        else:
            self.oldmeter = self.oldmeter + meter
            print("此车当前里程数为:" + str(self.oldmeter))
class Jiaoche(Cars):
    def __init__(self,make,model,year):
        super(Jiaoche,self).__init__(make,model,year)
        self.oldmeter = 10
xiaoche = Jiaoche("changcheng","xiaoche","1990")
xiaoche.description()
xiaoche.update_meter(20)
xiaoche.update_meter(20)
xiaoche.update_meter(20)

上方代码中的super()方法是一个特殊的函数,帮助python将父类和子类联系起来,这行代码,让python调用子类的父类方法__init__(),让子类的实例包含父类的所有属性。父类也称为超类。使用方法:

在子类中定义一个__init__函数,在该函数下使用super()方法:super(子类名称,self).__init__(参数列表,不含self),注意,同时在父类定义时,在父类名后面的参数列表中,要表明这是object对象。这是在python2.7中的用法。函数super() 需要两个实参:子类名和对象self 。为帮助Python将父类和子类关联起来,这些实参必不可少。另外,在Python 2.7中使用继承时,务必在定义父类时在括号内指定object 。

而在python2.0中,在super()函数中不需要这两个参数,同时,也不需要子啊定义父类时,在括号里指定object。

(2)给子类定义属性和方法

让一个类继承另一个类后,可以添加区分子类和父类所需要的新属性和新方法,只要在子类中定义就好。

(3)重写父类的方法

对于父类的方法,子类在继承的时候可以对它进行重写。为此,只需要在子类中定义这样一个方法,和父类同名即可。这样python将不会考虑父类中的方法,而只关注了你子类中的相应方法。

(4)将实例用作属性

在写一个类时,可能会给这个类添加很多很多的细节,导致属性和方法都很长。这种情况下,我们可以以将类的一部分提取出来,将一个大型的列拆分成多个协同工作的小类。如:

class Cars(object):
    def __init__(self,make,modle,year):
        self.make = make
        self.modle = modle
        self.year = year
    def description(self):
        print("这个车子的制造商是:" + self.make)
        print("这个车子的模型是:" + self.modle)
        print("这个车子的生产年份是:" + self.year)
class updateM():
    def __init__(self,oldmeter = 10):
        self.oldmeter = oldmeter
    def update_meter(self,meter):
        if self.oldmeter + meter > 50 :
            print("此车的里程数已达上限")
        else:
            self.oldmeter = self.oldmeter + meter
            print("此车的里程数为:" + str(self.oldmeter))
class Jioache(Cars):
    def __init__(self,make,modle,year):
        super(Jioache,self).__init__(make,modle,year)
        self.oldmeter = updateM().update_meter(10)
        self.oldruash = 7
    def update_ruash(self,ruash):
        self.oldruash = self.oldruash - ruash
        print("洗车的频率是:" + str(self.oldruash) +"天一次")
xiaobai = Jioache("bmw","yueye","2018")
xiaobai.oldruash = 5
xiaobai.update_ruash(2)
xiaobai.description()

运行结果:

这里把updateM作为一个小类单独划分了出来。

⑤导入类

使用from module_name import ...可以导入一个模块中的各种类

⑥python标准库

Python标准库 标准库 是一组模块,安装的Python都包含它。你现在对类的工作原理已有大致的了解,可以开始使用其他程序员编写好的模块了。可使用标准库中的任何函数和类,为此 只需在程序开头包含一条简单的import 语句。

14、文件和异常

①从文件中读取数据

(1)读取整个文件

首先,我们在该程序的目录下创建一个名为word的文本文件,其中包含三行信息(第一行hadoop,第二行spark,第三行hello world),使用如下代码,将这个文本文件中的内容打印出来:

with open("word.txt") as read_word:
    content = read_word.read()
    print(content)

执行结果如下:

第一行open()函数的作用是打开一个文件。在对文件进行操作时,不管你要以什么方式访问它,第一步都应该是打开这个文件,这样才能访问它。函数open只接收一个参数,即为要打开文件的名称。

关键字with表示在不需要访问文件后将其关闭。

有了文件对象后,使用read()方法将整个文本文件的全部内容显示出来。

相对于原始文件,上面的代码中输出在末尾多了一行空行。这是因为read()到达文件末尾时返回一个空字符串,而这个空字符串显示出来就是一个空行。要删除多出来的空行,可在print语句中使用.rstrip()(rstrip函数右删除空行)

(2)文件路径

当将文件名传递给函数open()时,python将在当前执行的文件所在目录中查找文件。有时候要查找的文件不在当前目录下时,就必须传入的是文件路径,让python到特定的位置下去找。这个文件路径可以是绝对路径也可以是想对路径。

(3)逐行读取:对文件对象使用for循环可以实现对文件内容的逐行读取。如:

with open("word\word.txt") as word:
    for line in word:
        print(line)

输出结果:

打印每一行的时候都会出现空行,要消除这些多余的空行可以调用.strip()方法

(4)创建一个包含文件各行内容的列表

使用关键字with 时,open() 返回的文件对象只在with 代码块内可用。如果要在with 代码块外访问文件的内容,可在with 代码块内将文件的各行存储在一个列表中,并在with 代码块外使用该列表。

将各行存储到一个列表中可以是用.readlines() 方法,该方法将一个文件中的各行存储在一个列表中,每一行是列表的一个元素。

注意:python在读取文件时将文本中的所有内容都视为字符串,如要当成整型用,先要使用int()函数转换。

②写入文件

(1)写入空文件

将文本写入文件时,在调用open()函数时需要提供另外一个实参,告诉python你要打开写入的文本。如:

with open("./yuanzhoulv","w") as wpy:
    wpy.writa("sfwer2as")

上例中,open函数用了两参数,第一个参数是要打开的文件名称,第二个参数("w")告诉python。我们要以写入模式打开这个文件。打开这个文件时,可以指定模式(读取模式 ('r' )、写入模式  ('w' )、附加模式('a' )或让你能够读取和写入文件的模式('r+' )。如果你省略了模式实参,Python将以默认的只读模式打开文件)

(2)写入多行

函数write() 不会在你写入的文本末尾添加换行符,因此想要写入多行文本时可以在一行的末尾加上“/n”

(3)附加到文件

在使用上面write的方式写入文件时,会覆盖掉你原有的所有文件,重新写入当前新的文本。若你不想将原有文件覆盖掉可以使用附加模式写入文本。使用a模式,write方法即可实现文本的附加。

③异常:在执行python时,如果遇到错误,python会创建一个异常对象,如果你编写了处理该异常的代码,程序将继续运行;如果你未对异常进行处理,程序将会停止,并返回一个Traceback,其中包含有关异常的报告。

在python中是使用try-except代码块来处理异常的。

使用try-except代码块,如:

try:
    print(5/0)
except ZeroDivisionError:
    print("除数不能为0")

④分析文本

计算单词个数:我们使用split()方法可以将字符串中的所有单词存储到一个列表中,split()方法以空格为分隔符将字符串拆分成多个部分。

⑤使用多个文件

可以将文件名存储在一个列表里,然后遍历整个列表,执行函数。

⑥失败时不返回任何信息

并非每一次的异常捕捉到后都要告诉用户。如果希望程序在发生异常时,像没事一样继续运行,则可以在expect代码块中使用pass。

⑦存储数据:使用json模块来存储信息

(1)使用json.dump()来存储数据:这个函数需要两个参数,第一个参数是要存储的数据,第二个参数是用于存储数据的文件对象,如:

import json
list = [2,3,4,5,6,7]
with open("./yuanzhoulv","w") as l:
    json.dump(list,l)

使用json.dump()这个函数之前首先要导入json模块,然后使用open()函数对文件执行可写入操作。

(2)使用json.load()函数来将文件中的内容读取到内存中。如:

import json
with open("./yuanzhoulv") as l:
    number = json.load(l)
print(number)

⑧重构:将代码划分为一系列可以完成具体工作的函数。如:

import json
def load_fl():
    with open ("./yu") as file_read:
        again = json.load(file_read)
        return again
def dump_fl():
    number = raw_input("请输入一串数字:")
    with open("./yu", "w") as file_read:
        json.dump(number, file_read)
        return number
def read_fl():
    try:
        pr_a = load_fl()
    except:
        dm = dump_fl()
        print("这组新数字是:" + dm)
    else:
        print("这组数原来是:" + str(pr_a))
read_fl()

15、测试代码

①测试函数

②③④⑤⑥⑦⑧⑨

阅读更多
换一批

没有更多推荐了,返回首页