python int及其它的知识

最新推荐文章于 2024-08-29 21:36:43 发布

大大U

最新推荐文章于 2024-08-29 21:36:43 发布

阅读量9.1k

点赞数 3

分类专栏： python

本文链接：https://blog.csdn.net/fzf1996/article/details/91490314

版权

python 专栏收录该内容

14 篇文章 1 订阅

订阅专栏

python的编程规范：PEP 8 https://legacy.python.org/dev/peps/pep-0008/

打印 print str.format（）

模块使用

类 class

有两种有效的属性名称，数据属性和方法。

_init_()

在Python中，函数的参数可以有默认值，也支持使用可变参数。如果在调用函数的时候如果没有传入对应参数的值时将使用该参数的默认值

因为我们可能会对0个或多个参数进行加法运算，而具体有多少个参数是由调用者来决定，我们作为函数的设计者对这一点是一无所知的，因此在不确定参数个数的时候，我们可以使用可变参数

# 在参数名前面的*表示args是一个可变参数
# 即在调用add函数时可以传入0个或多个参数
def add(*args):
    total = 0
    for val in args:
        total += val
    return total


print(add())
print(add(1))
print(add(1, 2))
print(add(1, 2, 3))
print(add(1, 3, 5, 7, 9))

我们在不同的模块中可以有同名的函数，在使用函数的时候我们通过import关键字导入指定的模块就可以区分到底要使用的是哪个模块中的foo函数

module1.py

```Python
def foo():
    print('hello, world!')
```

module2.py

```Python
def foo():
    print('goodbye, world!')
```

test.py

```Python
from module1 import foo

# 输出hello, world!
foo()

from module2 import foo

# 输出goodbye, world!
foo()
```

也可以按照如下所示的方式来区分到底要使用哪一个`foo`函数。

test.py

```Python
import module1 as m1
import module2 as m2

m1.foo()
m2.foo()
```

但是如果将代码写成了下面的样子，那么程序中调用的是最后导入的那个`foo`，因为后导入的foo覆盖了之前导入的`foo`。

test.py

```Python
from module1 import foo
from module2 import foo

# 输出goodbye, world!
foo()
```

test.py

```Python
from module2 import foo
from module1 import foo

# 输出hello, world!
foo()
```

if __name__ == '__main__' 我们简单的理解就是： 如果模块是被直接运行的，则代码块被运行，如果模块是被导入的，则代码块不被运行。

如果你有想在当前模块运行，而不想它被导入后运行，就把它放到这个条件下。这样的话除非直接运行该模块，if条件下的这些代码是不会执行的，因为只有直接执行的模块的名字才是“__main__”。

作用域;

def foo():
    b = 'hello'

    def bar():  # Python中可以在函数内部再定义函数
        c = True
        print(a)
        print(b)
        print(c)

    bar()
    # print(c)  # NameError: name 'c' is not defined


if __name__ == '__main__':
    a = 100
    # print(b)  # NameError: name 'b' is not defined
    foo()

上面的代码能够顺利的执行并且打印出100和“hello”，但我们注意到了，在bar函数的内部并没有定义a和b两个变量，那么a和b是从哪里来的。我们在上面代码的if分支中定义了一个变量a，这是一个全局变量（global variable），属于全局作用域，因为它没有定义在任何一个函数中。在上面的foo函数中我们定义了变量b，这是一个定义在函数中的局部变量（local variable），属于局部作用域，在foo函数的外部并不能访问到它；但对于foo函数内部的bar函数来说，变量b属于嵌套作用域，在bar函数中我们是可以访问到它的。bar函数中的变量c属于局部作用域，在bar函数之外是无法访问的。事实上，Python查找一个变量时会按照“局部作用域”、“嵌套作用域”、“全局作用域”和“内置作用域”的顺序进行搜索，前三者我们在上面的代码中已经看到了，所谓的“内置作用域”就是Python内置的那些隐含标识符min、len等都属于内置作用域）。

def foo():
    a = 200
    print(a)  # 200


if __name__ == '__main__':
    a = 100
    foo()
    print(a)  # 100

在调用foo函数后，我们发现a的值仍然是100，这是因为当我们在函数foo中写a = 200的时候，是重新定义了一个名字为a的局部变量，它跟全局作用域的a并不是同一个变量，因为局部作用域中有了自己的变量a，因此foo函数不再搜索全局作用域中的a。如果我们希望在foo函数中修改全局作用域中的a，代码如下所示。

def foo():
    global a
    a = 200
    print(a)  # 200


if __name__ == '__main__':
    a = 100
    foo()
    print(a)  # 200

我们可以使用global关键字来指示foo函数中的变量a来自于全局作用域，如果全局作用域中没有a，那么下面一行的代码就会定义变量a并将其置于全局作用域。同理，如果我们希望函数内部的函数能够修改嵌套作用域中的变量，可以使用nonlocal关键字来指示变量来自于嵌套作用域，请大家自行试验 .

在实际开发中，我们应该尽量减少对全局变量的使用，因为全局变量的作用域和影响过于广泛，可能会发生意料之外的修改和使用，除此之外全局变量比局部变量拥有更长的生命周期，可能导致对象占用的内存长时间无法被垃圾回收。事实上，减少对全局变量的使用，也是降低代码之间耦合度的一个重要举措，同时也是对迪米特法则的践行。减少全局变量的使用就意味着我们应该尽量让变量的作用域在函数的内部，但是如果我们希望将一个局部变量的生命周期延长，使其在函数调用结束后依然可以访问，这时候就需要使用闭包

python中的下划线

（1）_xxx

"单下划线 " 开始的成员变量相当于私有变量，也叫做保护变量，意思是只有类实例和子类实例能访问到这些变量，需通过类提供的接口进行访问（可以定义有点像java中的getter、setter方法，借助方法访问，而不是直接对变量动刀子）；不能用'from module import *'导入。其实，Python并没有真正的私有化支持，用下划线得到的是伪私有，也就是说如果你强行要用也是可以的，但不符合python的规范。我们应该尽量避免重新定义以下划线开头的变量。

单个下划线是一个Python命名约定，表示这个名称是供内部使用的。它通常不由Python解释器强制执行，仅仅作为一种对程序员的提示。

　　（2）__xxx

双下划线：类中的私有变量/方法名（Python的函数也是对象，所以成员方法称为成员变量也行得通）。" 双下划线 " 开始的是私有成员，意思是只有类对象自己能访问，连子类对象也不能访问到这个数据。

　　（3）__xxx__

系统定义名字，前后均有一个“双下划线” 代表python里特殊方法专用的标识，如 __init__（）代表类的构造函数。类似__xxx__这样的变量是特殊变量，可以被直接引用，但是有特殊用途，比如一个模块的__author__，__name__就是特殊变量，模块定义的文档注释（就是模块开头的字符串）也可以用特殊变量__doc__访问，我们自己的变量一般不要用这种变量名。
---------------------
作者：奔跑的Yancy
来源：CSDN
原文：https://blog.csdn.net/lyxleft/article/details/85691186
版权声明：本文为博主原创文章，转载请附上博文链接！

__int__与self

（1）、__init__方法的第一参数永远是self，表示创建的类实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。（2）、有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器会自己把实例变量传进去。self指实例地址（牢记），定义类函数加self形参。名字可以不要self，可以换为其它。

在继承时，传入的是哪个实例，就是那个传入的实例，而不是指定义了self的类的实例?

class Parent:
    def pprt(self):
        print(self)
 
class Child(Parent):
    def cprt(self):
        print(self)
c = Child()
c.cprt()
c.pprt()
p = Parent()
p.pprt()


<__main__.Child object at 0x0000000002A47080>  Child
<__main__.Child object at 0x0000000002A47080>  Child
<__main__.Parent object at 0x0000000002A47240> Parent

运行c.cprt()时应该没有理解问题，指的是Child类的实例。但是在运行c.pprt()时，等同于Child.pprt(c)，所以self指的依然是Child类的实例。

@property，getter和setter