Datawhale ----7 days for Python(任务三)

【任务三】

学习内容1

1.基本函数的构成：定义、实现和调用函数参数，函数返回值。 (第八章)

定义函数：
1.函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
2.任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
3.函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
4.函数内容以冒号起始，并且缩进。
def greet_user():
"""显示简单的问候语"""      #函数解释说明，指明函数的作用
	print("Hello!")
greet_user()              #调用函数
函数参数：形参和实参。形参在定义函数时体现，是函数完成其工作所需的一项信息。实参在调用函数时体现。
实参种类：
#位置实参:调用函数时每个实参都关联到函数定义的一个形参，形成映射关系，并且顺序很重要。
def describe_pet(animal_type, pet_name):
"""显示宠物的信息"""
	print("\nI have a " + animal_type + ".")
	print("My " + animal_type + "'s name is " + pet_name.title() + ".")
describe_pet('hamster', 'harry')      #实参和形参相对应
#关键字实参：是传递给函数的名称—值对，直接在实参中将名称和值关联起来了，因此向函数传递实参时不会混淆。关键字实参无需考虑函数调用中的实参顺序，还清楚地指出了函数调用中各个值的用途。
def describe_pet(animal_type, pet_name):
"""显示宠物的信息"""
	print("\nI have a " + animal_type + ".")
	print("My " + animal_type + "'s name is " + pet_name.title() + ".")
describe_pet(animal_type='hamster', pet_name='harry')    #关键字实参，顺序无关紧要
#默认值：在调用函数中给形参提供了实参时，Python将使用指定的实参值；否则，将使用形参的默认值。因此，给形参指定默认值后，可在函数调用中省略相应的实参。使用默认值可简化函数调用，还可清楚地指出函数的典型用法。
def describe_pet(pet_name, animal_type='dog'):
"""显示宠物的信息"""
	print("\nI have a " + animal_type + ".")
	print("My " + animal_type + "'s name is " + pet_name.title() + ".")
describe_pet(pet_name='willie')
#输出
I have a dog.
My dog's name is Willie.
#返回值：函数并非总是直接显示输出,相反,它可以处理一些数据,并返回一个或一组值。函数返回的值被称为返回值.在函数中,可使用return语句将值返回到调用函数的代码行.返回值能够将程序的大部分繁重工作移到函数中去完成，从而简化主程序。
def get_formatted_name(first_name, last_name, middle_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', 'hooker', 'lee')
print(musician)

Jimi Hendrix
John Lee Hooker

2.函数内部变量的作用域，可以通过locals()和globals()两个函数来了解。(第八章)

locals()函数会以字典类型返回当前位置的全部局部变量,无需传入参数。
ss = 'xiao y'
def game(dota):
	sf = 'shadow'
	print(locals())
>>>game('lol')
{'sf': 'shadow', 'dota': 'lol'}

globals()函数会以字典类型返回当前位置的全部全局变量,无参数。
ss = 'xiao y'
def game(dota):
	sf = 'shadow'
	print(globals())
>>>game('lol')
{ 'ss': 'xiao y', 'game': <function game at 0x0000000002461E18>}    #其他信息未显示

ss = 'xiao y'
def game(dota):
	global ss        #声明全局变量 ss
	sf = 'shadow'
	print(locals())
>>>game('lol')
>{'sf': 'shadow', 'dota': 'lol'}
总结：定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中

3.匿名函数:lambda，了解map函数，并用lambda完成列表（注：列表中各个元素全为数字类型）中每一个元素+1的操作。

python使用 lambda 来创建匿名函数。
1.lambda只是一个表达式，函数体比def简单很多。
2.lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
3.lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数
ss = lambda a,b:a+b      #a,b相加
print(ss(1,5))
6
map()函数会根据提供的函数对指定序列做映射。
map(function, iterable)
lst = [2,4,6]
add = lambda a:a+1
results = map(add,lst)
print(list(results))   
[3, 5, 7]

4.了解文件操作，如何写入，读取，追加，并了解读取文件中每一行的几种方式。(第十章)

1.读取文件
with open('pi_digits.txt') as file_object:
contents = file_object.read()
print(contents)
3.1415926535
8979323846
2643383279
2.逐行读取
filename = 'pi_digits.txt'
with open(filename) as file_object:
	for line in file_object:
	print(line)
3.1415926535
8979323846
2643383279
3.写入文件
filename = 'programming.txt'
with open(filename, 'w') as file_object:
	file_object.write("I love programming.")
4.写入多行
filename = 'programming.txt'
with open(filename, 'w') as file_object:
	file_object.write("I love programming.")
	file_object.write("I love creating new games.")
5.追加
filename = 'programming.txt'
with open(filename, 'a') as file_object:
	file_object.write("I also love finding meaning in large datasets.\n")
	file_object.write("I love creating apps that can run in a browser.\n")

通过with方法打开文件后程序会自动关闭文件，无需使用close()方法，实际应用时采用此方法可以节省很多精力。此外，逐行读取可用readline方法读取多行可用readlines方法。

学习内容2

1.创建和使用类(第九章)，为什么说python中一切皆对象?，object类代表了什么?

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
局部变量：定义在方法中的变量，只作用于当前实例的类。
实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
实例化：创建一个类的实例，类的具体对象。
方法：类中定义的函数。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
class Dog():
	print("It's a dog")
dog = Dog()

2.使用类和实例(第九章)，self关键字有什么作用?

class Dog():
	"""一次模拟小狗的简单尝试"""
	def __init__(self, name, age):
	"""初始化属性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!")
my_dog = Dog('Vodka',20)
print(my_dog.name.title(),my_dog.age)
my_dog.sit()
my_dog.roll_over()
#输出：
Vodka 20
Vodka is now sitting.
Vodka rolled over!

Python调用__init__()方法来创建Dog 实例时,将自动传入实参self.每个与类相关联的方法调用都自
动传递实参self,它是一个指向实例本身的引用,让实例能够访问类中的属性和方法。我们创建Dog 实例
时，Python将调用Dog 类的方法__init__().我们将通过实参向Dog() 传递名字和年龄;self 会自动传
递，因此我们不需要传递它.每当我们根据Dog类创建实例时,都只需给最后两个形参（name 和age）提供
值。

3.继承(第九章)（附加：类中三大特性，封装，继承和多态，c++和java都有多态，python明面上是没有多态的，但是也可以实现，如果有能力，可以探究下如何实现）

代码引用自菜鸟教程–继承

class Parent():        # 定义父类
   parentAttr = 100
   def __init__(self):
      print("调用父类构造函数")
 
   def parentMethod(self):
      print('调用父类方法')
 
   def setAttr(self, attr):
      Parent.parentAttr = attr
 
   def getAttr(self):
      print("父类属性 :",Parent.parentAttr)
 
class Child(Parent): # 定义子类
    def __init__(self):
        print("调用子类构造方法")
    def childMethod(self):
        print('调用子类方法')
 
c = Child()          # 实例化子类
c.childMethod()      # 调用子类的方法
c.parentMethod()     # 调用父类方法
c.setAttr(200)       # 再次调用父类的方法 - 设置属性值
c.getAttr()          # 再次调用父类的方法 - 获取属性值

调用子类构造方法
调用子类方法
调用父类方法
父类属性 : 200
************************************************************************
class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self,make,model,year):
        """初始化"""
        self.make = make
        self.model = model
        self.year = year
        self.od_reading = 0     #新增属性值,汽车里程
    def get_descriptive_name(self):
        """返回整洁的描述信息"""
        long_name = str(self.year)+ " "+ self.make+ " "+ self.model
        return long_name.title()
    def read_od(self):         #读取汽车里程
        print("This car has "+ str(self.od_reading)+ " miles on it.")
    def update_od(self,mileage):  #通过方法更新属性值
        """禁止回调里程"""
        if mileage >= self.od_reading:
             self.od_reading = mileage
        else:
            print("You can't rool back an odometer!")
    def incremet_od(self,miles):  #递增里程
        self.od_reading += miles
    def fill_gas_tank(self):
        """加满油箱"""
        print("The fuel tank is full")
class Battery():
    """一次模拟电瓶的简单尝试"""
    def __init__(self,battery_size=70):
        self.battery_size = battery_size
    def describe_battery(self):     #打印电瓶容量
        print("This car has a "+ str(self.battery_size)+ "-kwh battery.")

class ElecCar(Car):               #父类位于子类前面，定义子类时括号内指定父类名称
    """电动汽车的独特之处"""
    def __init__(self, make, model, year):
        """初始化父类属性"""
        super().__init__(make,model,year)
        self.battery = Battery()      #定义子类特有属性，将实例用作属性
    def fill_gas_tank(self):        #重写父类
        """加满油箱"""
        print("This car doesn't need a gas tank!")
#父类测试
newcar = Car('audi','a4',2016)
print(newcar.get_descriptive_name())
newcar.od_reading = 15          #直接修改属性值
newcar.read_od()
newcar.update_od(24)            #通过方法修改属性值
newcar.read_od()
newcar.incremet_od(100)
newcar.read_od()
print("\n",end='')
#继承子类测试
test = ElecCar('tesla','model s','2016')
print(test.get_descriptive_name())
test.fill_gas_tank()
test.battery.describe_battery()

#输出结果
2016 Audi A4
This car has 15 miles on it.
This car has 24 miles on it.
This car has 124 miles on it.

2016 Tesla Model S
This car doesn't need a gas tank!
This car has a 70-kwh battery.

4.import类到其他文件使用的几种方法,并在类中实现一个函数打印__file__关键字，看下__file__前后的变化，并解释原因(第九章)

from moduleName import className      #知道具体使用哪个类的名字
from moduleName import *       #导入模块中的所有类
import moduleName        #应用是需使用句点符号，避免同名冲突发生异常