Python学习笔记

摘要：数字和字符串，不能改变对象本身，只能改变引用的指向，称为不可变数据对象。从开始，依次增加的值，直至等于或者大于将会输出。该函数输入姓名和各科的成绩，输出姓名和总共成绩。表明该参数是关键字参数，通常来讲关键字参数是放在函数参数列表的最后。

函数中使用的变量是局部的

如果在外面的变量在函数中使用，需要加global关键字

APPLY = 100 # 全局变量
a = None
def fun():
    global a    # 使用之前在全局里定义的 a
    a = 20      # 现在的 a 是全局变量了
    return a+100

print(APPLE)    # 100
print("a past:", a)  # None
fun()
print("a now:", a)   # 20

id()可以显示内存地址

列表可以通过引用其元素，改变对象自身(in-place change)。这种对象类型，称为可变数据对象(mutable object)，词典也是这样的数据类型。

数字和字符串，不能改变对象本身，只能改变引用的指向，称为不可变数据对象(immutable object)。元组(tuple)，尽管可以调用引用元素，但不可以赋值，因此不能改变对象自身，所以也算是immutable object。

当使用浅拷贝时，python只是拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。看代码：

>>> import copy
>>> a=[1,2,3]
>>> c=copy.copy(a)  #拷贝了a的外围对象本身,
>>> id(c)
4383658568
>>> print(id(a)==id(c))  #id 改变 为false
False
>>> c[1]=22222   #此时，我去改变c的第二个值时，a不会被改变。
>>> print(a,c)
[1, 2, 3] [1, 22222, 3] #a值不变,c的第二个值变了，这就是copy和‘==’的不同

deepcopy对外围和内部元素都进行了拷贝对象本身，而不是对象的引用。

#copy.copy()

>>> a=[1,2,[3,4]]  #第三个值为列表[3,4],即内部元素
>>> d=copy.copy(a) #浅拷贝a中的[3，4]内部元素的引用，非内部元素对象的本身
>>> id(a)==id(d)
False
>>> id(a[2])==id(d[2])
True
>>> a[2][0]=3333  #改变a中内部原属列表中的第一个值
>>> d             #这时d中的列表元素也会被改变
[1, 2, [3333, 4]]


#copy.deepcopy()

>>> e=copy.deepcopy(a) #e为深拷贝了a
>>> a[2][0]=333 #改变a中内部元素列表第一个的值
>>> e
[1, 2, [3333, 4]] #因为时深拷贝，这时e中内部元素[]列表的值不会因为a中的值改变而改变

创建二维数组

myList = [([0] * 3) for i in range(4)]
#以上会出现浅拷贝，
>>> lists = [[] for i in range(3)]
>>> lists[0].append(3)
>>> lists[1].append(5)
>>> lists[2].append(7)
#避免浅拷贝

var = var1 if condition else var2

如果 condition 的值为 True, 那么将 var1 的值赋给 var;如果为 False 则将 var2 的值赋给 var。

if condition1:
    true1_expressions
elif condition2:
    true2_expressions
elif condtion3:
    true3_expressions
elif ...
    ...
else:
    else_expressions

如果有多个判断条件，那可以通过 elif 语句添加多个判断条件，一旦某个条件为 True，那么将执行对应的 expression。

在 Python 内置了工厂函数，range 函数将会返回一个序列，总共有三种使用方法

range(start, stop)

其中 start 将会是序列的起始值，stop为结束值，但是不包括该值，类似 数学中的表达 [start, stop),左边为闭区间，右边为开区间。

for i in range(1, 10):
    print(i)

上述表达将会返回 1-9 所有整数，但不包含 10

range(stop)

如果省略了 start 那么将从 0 开始，相当于 range(0, stop)

range(start, stop, step)

step 代表的为步长，即相隔的两个值得差值。从 start 开始，依次增加 step 的值，直至等于或者大于 stop

for i in range(0,13, 5):
    print(i)

将会输出 0, 5, 10。

Python 共内置了 list、 tuple 、dict 和 set 四种基本集合，每个集合对象都能够迭代。

在 Python 中集合类型有 list、 tuple 、dict 和 set 等，如果该集合对象作为 while 判断语句， 如果集合中的元素数量为 0，那么将会返回 False, 否则返回 True。

a = range(10)
while a:
    print(a[-1])
    a = a[:len(a)-1]

上述程序将会返回 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 程序首先判断列表是否空，如果不为空，则 打印出最后一个内容，然后使用切片操作去掉最后一个元素，并更新列表；如此重复，直至列表为空。

variable=input() 表示运行后，可以在屏幕中输入一个数字，该数字会赋值给自变量。

python 中 print 字符串 要加""或者""

换行命令

达到 tab 对齐

使用 open 能够打开一个文件, open 的第一个参数为文件名和路径 ‘my file.txt’, 第二个参数为将要以什么方式打开它, 比如 w 为可写方式. 如果计算机没有找到 ‘my file.txt’ 这个文件, w 方式能够创建一个新的文件, 并命名为 my file.txt

my_file=open("my file.txt","w")   #用法: open("文件名","形式"), 其中形式有"w":write;"r":read.
my_file.write(text)               #该语句会写入先前定义好的 text
my_file.close()                   #关闭文件

open("my file.txt","a") 打开类型为 a ，a 即表示 append。

使用 file.read() 能够读取到文本的所有内容.

file= open("my file.txt","r") 
content=file.read()  
print(content)

""""
This is my first test.
This is the second line.
This the third line.
This is appended file.    
""""

如果想在文本中一行行的读取文本, 可以使用 file.readline(), file.readline() 读取的内容和你使用的次数有关, 使用第二次的时候, 读取到的是文本的第二行, 并可以以此类推:

file= open("my file.txt","r") 
content=file.readline()  # 读取第一行
print(content)

""""
This is my first test.
""""

second_read_time=file.readline()  # 读取第二行
print(second_read_time)

"""
This is the second line.
"""

如果想要读取所有行, 并可以使用像 for 一样的迭代器迭代这些行结果, 我们可以使用file.readlines(), 将每一行的结果存储在 list 中, 方便以后迭代。

file= open("my file.txt","r") 
content=file.readlines() # python_list 形式
print(content)

""""
["This is my first test.
", "This is the second line.
", "This the third line.
", "This is appended file."]
""""

# 之后如果使用 for 来迭代输出:
for item in content:
    print(item)
    
"""
This is my first test.

This is the second line.

This the third line.

This is appended file.
"""

(tuple)

[list]

详细文档

{dict}

详细文档

函数声明只需要在需要默认参数的地方用 = 号给定即可, 但是要注意所有的默认参数都不能出现在非默认参数的前面。

如果想要在执行脚本的时候执行一些代码，比如单元测试，可以在脚本最后加上单元测试 代码，但是该脚本作为一个模块对外提供功能的时候单元测试代码也会执行，这些往往我们不想要的，我们可以把这些代码放入脚本最后：

if __name__ == "__main__":
    #code_here

如果执行该脚本的时候，该 if 判断语句将会是 True,那么内部的代码将会执行。 如果外部调用该脚本，if 判断语句则为 False,内部代码将不会执行。

顾名思义，函数的可变参数是传入的参数可以变化的，1个，2个到任意个。当然可以将这些 参数封装成一个 list 或者 tuple 传入，但不够 pythonic。使用可变参数可以很好解决该问题，注意可变参数在函数定义不能出现在特定参数和默认参数前面，因为可变参数会吞噬掉这些参数。

def report(name, *grades):
    total_grade = 0
    for grade in grades:
        total_grade += grade
    print(name, "total grade is ", total_grade)

定义了一个函数，传入一个参数为 name, 后面的参数 *grades 使用了 * 修饰，表明该参数是一个可变参数，这是一个可迭代的对象。该函数输入姓名和各科的成绩，输出姓名和总共成绩。所以可以这样调用函数 report("Mike", 8, 9)，输出的结果为 Mike total grade is 17, 也可以这样调用 report("Mike", 8, 9, 10)，输出的结果为 Mike total grade is 27

关键字参数可以传入0个或者任意个含参数名的参数，这些参数名在函数定义中并没有出现，这些参数在函数内部自动封装成一个字典(dict).

def portrait(name, **kw):
    print("name is", name)
    for k,v in kw.items():
        print(k, v)

定义了一个函数，传入一个参数 name, 和关键字参数 kw，使用了 ** 修饰。表明该参数是关键字参数，通常来讲关键字参数是放在函数参数列表的最后。如果调用参数portrait("Mike", age=24, country="China", education="bachelor") 输出:

name is Mike
age 24
country China
education bachelor

通过可变参数和关键字参数，任何函数都可以用 universal_func(*args, **kw) 表达。

在类中，方法外的变量，所有实例对象公用

在类方法中，一般在__init__中声明定义，对象之间独立

单下划线是Protect

双下划线是Private

设置属性的默认值, 直接在def里输入即可，如下:

def __init__(self,name,price,height=10,width=14,weight=16):

这里和视频有点差别，我自己写了另外一个模块，是计算五年复利本息的模块,代码如下：模块写好后保存在默认文件夹：balance.py

d=float(input("Please enter what is your initial balance: 
"))
p=float(input("Please input what is the interest rate (as a number): 
"))
d=float(d+d*(p/100))
year=1
while year<=5:
    d=float(d+d*p/100)
    print("Your new balance after year:",year,"is",d)
    year=year+1
print("your final year is",d)

新开一个脚本，import balance

import balance

""""
Please enter what is your initial balance:
50000  # 手动输入我的本金
Please input what is the interest rate (as a number):
2.3  #手动输入我的银行利息
Your new balance after year: 1 is 52326.45
Your new balance after year: 2 is 53529.95834999999
Your new balance after year: 3 is 54761.14739204999
Your new balance after year: 4 is 56020.653782067144
Your new balance after year: 5 is 57309.12881905469
your final year is 57309.12881905469
""""

在Mac系统中，下载的python模块会被存储到外部路径site-packages，同样，我们自己建的模块也可以放到这个路径，最后不会影响到自建模块的调用。

输出错误：try:, except ... as ...: 看如下代码

try:
    file=open("eeee.txt","r")  #会报错的代码
except Exception as e:  # 将报错存储在 e 中
    print(e)
"""
[Errno 2] No such file or directory: "eeee.txt"
"""

处理错误：会使用到循环语句。首先报错：没有这样的文件No such file or directory. 然后决定是否输入y, 输入y以后，系统就会新建一个文件（要用写入的类型），再次运行后，文件中就会写入ssss

try:
    file=open("eeee.txt","r+")
except Exception as e:
    print(e)
    response = input("do you want to create a new file:")
    if response=="y":
        file=open("eeee.txt","w")
    else:
        pass
else:
    file.write("ssss")
    file.close()
"""
[Errno 2] No such file or directory: "eeee.txt"
do you want to create a new file:y

ssss  #eeee.txt中会写入"ssss"

笔记大纲参考莫烦PYTHON

浅拷贝和深拷贝参考python 引用和对象理解和Python-copy()与deepcopy()区别

list和dict参考菜鸟教程