python教程入门学习Python基础学习

Posted 2021-12-08 梦子mengy7762

Python的函数参数传递

在Python中，strings，tuples=(‘abc’,123,2.2,'join)，numbers 是不可更改的对象；list=[‘abc’,123,2.23,‘john’],dict等则是可以修改的对象。代码示例：

a = 1
def fun(a):
a = 2
fun(a)
print a # 1

a = []
def fun(a):
a.append(1)
fun(a)
print a # [1]

静态方法,类方法和实例方法。

def foo(x):
print "executing foo(%s)"%(x)
class A(object):
def foo(self,x):
print "executing foo(%s,%s)"%(self,x)
@classmethod
def class_foo(cls,x):
print "executing class_foo(%s,%s)"%(cls,x)
@staticmethod
def static_foo(x):
print "executing static_foo(%s)"%x
a=A()

这个self和cls是对类或者实例的绑定,对于一般的函数来说我们可以这么调用foo(x),这个函数就是最常用的,它的工作跟任何东西(类,实例)无关.对于实例方法,我们知道在类里每次定义方法的时候都需要绑定这个实例,就是foo(self, x),为什么要这么做呢?因为实例方法的调用离不开实例,我们需要把实例自己传给函数,调用的时候是这样的a.foo(x)(其实是foo(a, x)).类方法一样,只不过它传递的是类而不是实例,A.classfoo(x).注意这里的self和cls可以替换别的参数,但是python的约定是这俩,还是不要改的好.对于静态方法其实和普通的方法一样,不需要对谁进行绑定,唯一的区别是调用的时候需要使用a.staticfoo(x)或者A.static_foo(x)来调用.

类变量和实例变量

class Person:
name=[]
p1=Person()
p2=Person()
p1.name.append(1)
print p1.name # [1]
print p2.name # [1]
print Person.name # [1]

class Test(object):
num_of_instance = 0
def __init__(self, name):
self.name = name
Test.num_of_instance += 1
if __name__ == '__main__':
print Test.num_of_instance
t1 = Test('jack')
print Test.num_of_instance
t2 = Test('lucy')
print t1.name , t1.num_of_instance
print t2.name , t2.num_of_instance

推导式

列表推导式(list) 提供一种方便的列表创建方法，返回一个列表。格式：用中括号括起来，中间用for语句，后面跟if语句用作判读，满足条件的传到for语句前面用作构建先的列表.

>>> li=[i*2 for i in range(10) if i % 2 == 0]
>>> print (li)
[0, 4, 8, 12, 16]
>>>

字典推导式(dic) 格式：d = {key: value for (key, value) in iterable}

>>> mca={"a":1, "b":2, "c":3, "d":4}
>>> dicts={v:k for k,v in mca.items()}
>>> print (dicts)
{1: 'a', 2: 'b', 3: 'c', 4: 'd'}
>>>

集合推导式（跟列表推导式的区别：1.不使用中括号，使用大括号；2.结果中无重复；3.结果是一个set()集合，集合里面是一个序列）

>>> squared={i*2 for i in [1,1,2]}
>>> print (squared)
set([2, 4])
>>>

Python中单下划线和双下划线

_foo:

在一个模块中以单下划线开头的变量和函数被默认当作内部函数，如果使用 from a module import * 导入时，这部分变量和函数不会被导入。不过值得注意的是，如果使用 import amodule 这样导入模块，仍然可以用 amodule.somevar 这样的形式访问到这样的对象；一种约定,用来指定变量私有.程序员用来指定私有变量的一种方式.

__foo:

双下划线开头的命名形式在 Python 的类成员中使用表示名字改编 (Name Mangling)，即如果有一 Test 类里有一成员 x，那么 dir(Test) 时会看到_Test_x 而非 __x。这是为了避免该成员的名称与子类中的名称冲突。

foo:

一种约定,Python内部的名字,用来区别其他用户自定义的命名,以防冲突.双下划线开头双下划线结尾的是一些 Python 的“魔术”对象，如类成员的 init、del 等，以及全局的 file、name 等。 Python 官方推荐永远不要将这样的命名方式应用于自己的变量或函数，而是按照文档说明来使用。

>>> class MyClass():
... def __init__(self):
... self.__superprivate = "Hello"
... self._semiprivate = ", world!"
...
>>> mc = MyClass()
>>> print mc.__superprivate
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: myClass instance has no attribute '__superprivate'
>>> print mc._semiprivate
, world!
>>> print mc.__dict__
{'_MyClass__superprivate': 'Hello', '_semiprivate': ', world!'}

字符串格式化:%和.format

对于%最烦人的是它无法同时传递一个变量和元组.

name = (1,2,3)
print ("hi there %s" % name) # 报错
print ("hi there %s" % (name,)) # 提供一个单元素的数组而不是一个参数

format通过{}和.来代替%

print ("{0},{1}".format('lujf',123))

通过关键字参数

print ("{name},{age}".format(name='lujf',age=23))

通过对象属性

class Person:
def __init__(self,name,age):
self.name,self.age = name,age
def __str__(self):
return 'This guy is {self.name},is {self.age} old'.format(self=self)

通过下标

p = ['lujf',23]
print ('{0[0]},{0[1]}'.format(p))

迭代器和生成器

迭代器：

迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问，知道所有的元素被访问完结束。迭代器只能往前不会后退。对于原生支持随机访问的数据结构（如tuple、list），迭代器和经典for循环的索引访问相比并无优势，反而丢失了索引值（可以使用内建函数enumerate()找回这个索引值）;但对于无法随机访问的数据结构（比如set）而言，迭代器是唯一的访问元素的方式。迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合，比如几个G的文件，或是斐波那契数列等等;迭代器更大的功劳是提供了一个统一的访问集合的接口，只要定义了iter()方法对象，就可以使用迭代器访问。迭代器有两个基本的方法:

next方法：返回迭代器的下一个元素;_iter_方法：返回迭代器对象本身

class Fab(object):
def __init__(self, max):
self.max = max
self.n, self.a, self.b = 0, 0, 1
def __iter__(self):
return self
def next(self):
if self.n < self.max:
r = self.b
self.a, self.b = self.b, self.a + self.b
self.n = self.n + 1
return r
raise StopIteration() #python处理迭代器越界是抛出StopIteration异常

使用迭代器：使用内建的工厂函数iter(iterable)可以获取迭代器对象：

>>> lst = range(5)
>>> it = iter(lst)
>>> it
<listiterator object at 0x01A63110>

使用next()方法可以访问下一个元素：

>>> it.next()
0
>>> it.next()
1
>>> it.next()
2

事实上，因为迭代器如此普遍，python专门为for关键字做了迭代器的语法糖。在for循环中，Python将自动调用工厂函数iter()获得迭代器，自动调用next()获取元素，还完成了检查StopIteration异常的工作。生成器：带有 yield 的函数在 Python 中被称之为 generator（生成器）。

def fab(max):
n, a, b = 0, 0, 1
while n < max:
yield b
a, b = b, a + b
n = n + 1

简单地讲，yield 的作用就是把一个函数变成一个 generator，带有 yield 的函数不再是一个普通函数，Python 解释器会将其视为一个 generator，调用 fab(5) 不会执行 fab 函数，而是返回一个 iterable 对象！在 for 循环执行时，每次循环都会执行 fab 函数内部的代码，执行到 yield b 时，fab 函数就返回一个迭代值，下次迭代时，代码从 yield b 的下一条语句继续执行，而函数的本地变量看起来和上次中断执行前是完全一样的，于是函数继续执行，直到再次遇到 yield。看起来就好像一个函数在正常执行的过程中被 yield 中断了数次，每次中断都会通过 yield 返回当前的迭代值。return的作用:在一个生成器中，如果没有return，则默认执行到函数完毕；如果遇到return,如果在执行过程中 return，则直接抛出 StopIteration 终止迭代。

*args and **kwargs

如果我们不知道往函数中传递多少个关键词参数或者想传入字典的值作为关键词参数的时候我们可以使用**kwargs。两个星号把字典解包成关键词参数。

def table_things(**kwargs):
for name, value in kwargs.items(): #Python 字典(Dictionary) items()方法
print ('{} = {}'.format(name, value))
table_things(apple = 'fruit', cabbage = 'vegetable')
#输出
#apple = fruit
#cabbage = vegetable

Python 的 is 和 ==

python中的对象包含三要素：id、type、value，其中 id 用来唯一标识一个对象。is是对比地址，==是对比值。最后，如果你的时间不是很紧张，并且又想快速的python提高，最重要的是不怕吃苦，建议你可以架微♥信：762459510 ，那个真的很不错，很多人进步都很快，需要你不怕吃苦哦！大家可以去添加上看一下~

lambda表达式

简单来说，lambda表达式通常是当你需要使用一个函数，但是又不想费脑袋去命名一个函数的时候使用，也就是通常所说的匿名函数。

#示例
f = lambda x,y,z: x + y + z
print(f(1,2,3))
L = {'f1':(lambda x,y: x**2 + y**2),
'f2':(lambda x,y: x**3 + y**3),
'f3':(lambda x,y: x**4 + y**3)}
print(L['f2'](3,2))

python福利教程领取方式：
1、点赞+评论（勾选“同时转发”）
2、关注小编。并私信回复关键字【19】
（一定要私信哦~点击我的头像就能看到私信按钮了）