python中的一切皆对象

包

• 包理解为文件夹>模块理解为py文件>类（其中包含函数和变量，它们不应被认为是在组织结构中，而应被认为是类的特性,例如一个班级的同学的爱好等，都应被认为是特性，而不是组织结构)
• 一个模块中可以有多个类
• 其它语言如C的dll包，java的jar包
• 包中可以再包含子包
• 文件夹中包含1个init.py文件，则该文件夹被认为是1个包
• 运行一个包中的模块时，会在包中生成pycache文件夹，用来存储编译的二进制文件(后缀为.pyc)，可以提高程序的运行效率
• 导入模块的办法
  1. 方式1：import t.a1 as m print(m.a)
  2. 方式2：from t.a1 import a,b print(a)
  3. 方式3：from t.a1 import *
  4. 可以通过在py文件前面定义 _ all _ = [ 变量名 ] 来定义外面可以访问到的变量
  5. init文件的作用是在导入包或是导入包中的一个py模块时，都会自动执行init里面的代码
  6. 引入包的级别不能高于或等于入口文件的级别
  7. 因为入口文件的name被改为main ，所以入口文件不能使用相对路径导入其它模块会提示找不到，解决办法
     1. 使用绝对路径导入
     2. 需要在入口文件的上一级，使用模块方式运行python -m demo.main

函数

1. 函数使用def定义，如果没有返回值，默认返回None
2. 函数不能自己调用自己，例如以下，会导致无限递归错误,并且要避免和内置函数名相同

'''
def print(a):
print(a)
'''

3. 多返回值的函数推荐用有意义的变量来接收返回的结果
4. 函数需要先定义，再调用，注意顺序

'''
python内置了许多基本的函数
'''
a = 1.1234
print(round(a,2))

1.12

'''
通常，我们建议这样写
'''
result = round(a,2)
print(result)

1.12

help(round)

Help on built-in function round in module builtins:

round(...)
    round(number[, ndigits]) -> number
    
    Round a number to a given precision in decimal digits (default 0 digits).
    This returns an int when called with one argument, otherwise the
    same type as the number. ndigits may be negative.

import this

def a(b,c):
    a1 = b*3
    a2 = c*2+10
    return a1,a2

asa=a(3,6)
kill1,kill2=a(3,6)
print(asa[0],asa[1])
print(kill1,kill2)
print(type(asa))

9 22
9 22
<class 'tuple'>

序列的解包

a=1,2,3
print(type(a))
b,c,d=a
print(b,c,d)

<class 'tuple'>
1 2 3

a=b=c=1
print(a,b,c)

1 1 1

函数的参数

1. 必须参数
   1. 形参 add(x,y)
   2. 实参 add(1,2)
   3. 关键字参数 add(y=1,x=2) 增强代码的可读性
   4. 非默认参数，不能放在默认参数之后
   5. 参数传递的类型不对可能报错，善用str、int等类型转换函数
   6. 调用过程中默认参数和形参不能混在一起
2. 可变参数
3. 函数外部定义的变量叫全局变量，内部定义的变量是局部变量
4. 变量的作用域具有链式特性，又称作用域链，逐级向上去寻找
5. python只有函数级作用域，没有块级作用域的概念，因此for外面可以打印内部的内容，而不需要像c一样先在外面定义c=''
6. 全局变量不仅仅局限于模块内部
7. 通过global定义全局变量

def demo(*param):
    print(param)
    print(type(param))
    
demo(1,2,3,4,5,6)

(1, 2, 3, 4, 5, 6)
<class 'tuple'>

'''
不应该这样写，会导致传递进的是二维数组
'''
demo((1,2,3,4,5,6))

((1, 2, 3, 4, 5, 6),)
<class 'tuple'>

'''
变量的解包
'''
a=(1,2,3,4,5,6)
demo(*a)

(1, 2, 3, 4, 5, 6)
<class 'tuple'>

def demo1(param):
    print(param)
demo1((1,2,3,4,5,6))

(1, 2, 3, 4, 5, 6)

def demo2(a,*b,c=3):
    print(a)
    print(b)
    print(c)
    
demo2('a',1,2,3,c='asa')

a
(1, 2, 3)
asa

def squsum(*a):
    sum=0
    for i in a:
        sum+=i*i
    print(sum)
    
squsum(1,2,3)

14

squsum(*(1,2,3))

14

def city_temp(**param):
    print(param)
    print(type(param))
    pass

city_temp(bj='32',pj='22',sh='32')

{'bj': '32', 'pj': '22', 'sh': '32'}
<class 'dict'>

def city_temp(*param1,**param):
    print(param1)
    print(param)
    for key,value in param.items():
        print(key,' : ',value)

a={'bj':'32','pj':'22','sh':'32'}
city_temp(**a)

()
{'bj': '32', 'pj': '22', 'sh': '32'}
bj  :  32
pj  :  22
sh  :  32

city_temp(1)

(1,)
{}

作用域

c=50 # 全局变量

def add(x,y):
    c=x+y # 局部变量
    print(c)
    
add(1,2)
print(c)

3
50

def demo():
#     此处定义的c相对于外部函数是局部变量，相对于for不是
    c=50
    for i in range(0,9):
        c+=1
        a='for循环内部变量'
    print(c)
    print(a)
demo()

59
for循环内部变量

'''
变量就近取值
'''
c=1

def func1():
#     c=2
    def func2():
#         c=3
        print(c)
    func2()
func1()

1

def demo():
    global c
    c=2
    
demo()
print(c)

2

类

1. 类的定义建议首字母大写，变量建议用_连接
2. init构造函数只能返回none
3. 局部变量不会覆盖全局变量（在类中定义的变量），对象中的实例变量使用self.属性来保存，仔细理解self代表的是实例