【python编程】-入门系列知识点总结

最新推荐文章于 2024-04-24 13:35:29 发布

昔我往矣wood

最新推荐文章于 2024-04-24 13:35:29 发布

阅读量75

点赞数

分类专栏： python编程练习文章标签： python

本文链接：https://blog.csdn.net/zhuge2017302307/article/details/120275497

版权

python编程练习专栏收录该内容

23 篇文章 4 订阅

订阅专栏

本篇博客写前三篇文章：入门系列1、2和3的知识点详细总结和介绍。

l1=[[0 for i in range(3)] for j in range(3)]
for i in range(3):
    for j in range(3):
        l1[i][j]=i*j
print(l1)

l2=[[] for i in range(3)]
for i in range(3):
    for j in range(3):
        l2[i].append(i*j)
print(l2)

l3=[]
for i in range(3):
    l3.append([])
    for j in range(3):
        l3[i].append(i*j)
print(l3)

上面的第一种是直接建立了一个全是0的二维数组，赋了初值，所以可以直接用下标引用；第二种和第三种都是通过插入来生成二维数组，所示使用append方法。建议使用第一种。

2. 列表（元组）和字典的相互转化

（1）字符串与列表（元组）之间的转化

字符串—>列表或者元组：字符串中每个字符为列表（元组）中的一个元素

列表（元组）—>字符串：整个列表或者元组转化为字符串，包括里面元素的引号，以及元组之间的逗号，还有 [ ] 和（）号。

（2）字典转化为列表（元组）

直接转化默认只将键转化过去，也可以分别转化键和值：

dic={1:'a',2:'b'}
print(list(dic))
print(list(dic.keys()))
print(list(dic.values()))

输出：
[1, 2]
[1, 2]
['a', 'b']

访问字典方法：

dic={1:'a',2:'b'}

for key,value in dic.items():# 直接访问键和对应的值，使用dic.items()方法
    print(key,value)
    
for key in dic.keys(): #访问所有的键，使用dic.keys()方法
    print(key)
    
for value in dic.values():
    print(value)

（3）列表（元组）转化为字典

首先，列表不能直接转化为字典。

第一种方法，使用zip()函数，将两个列表（元组）内的元素两两组合形成键和对应的值。同时注意，两个列表长度不一样时，多出的元素在另一个列表中无匹配元素，字典不展示多出的元素。

a = ['a1','a2','a3']
b = ['b1','b2']
d = zip(a,b)
print(dict(d)) 

输出：
{'a1': 'b1', 'a2': 'b2'}

第二种方法，使用嵌套列表。这个要求两个列表内只能有两个元素，将列表内的元素自行组合，每个列表的元素进行配对键和值。

a = ['a1','a2']
b = ['b1','b2']
c = [a,b]
print(dict(c))

输出：
{'a1': 'a2', 'b1': 'b2'}

# 相当于遍历子列表，如下
# dit = {}
# for i in c:
#     dit[i[0]] = i[1]

3. 逆转输出列表

两种方法，一种逆转输出（同时提供了一种遍历列表的方法：三冒号法），一种使用list.reverse()方法。注意，后者没有返回值，直接逆转原来的列表：

l1=[1,2,3,4]

for i in l1[::-1]:
    print(i)
输出：
4
3
2
1

l1.reverse()
print(l1)
输出：
[4, 3, 2, 1]

遍历列表：[ : : ]。参数1默认是0，参数2默认是最后一个元素，参数3表示间隔，默认1。一般访问到最后一个元素不写参数2。

4. lambda创建匿名函数

python用lambda来创建匿名函数。lambda仅仅是一个表达式，函数体比def简单很多。

——lambda的主题是一个表达式，而不是代码块。仅能封装有限的逻辑进去；

——lambda函数拥有自己的命名空间，且不能访问自有参数列表或全局参数以外的参数；

lambda函数的语法只包含一个语句：

fun_name = lambda arg1,arg2 : expression

其中arg2，arg2为参数，可以有若干个，冒号后面是表达式，函数名在最前面。

举例如下：

sum = lambda x,y : x+y
print(sum(2,3))

举例2：实现取较大值或者较小值的比较

MAXIMUM = lambda x,y :  (x > y) * x + (x < y) * y
MINIMUM = lambda x,y :  (x > y) * y + (x < y) * x
 
if __name__ == '__main__':
    a = 10
    b = 20
    print ('The largar one is %d' % MAXIMUM(a,b))
    print ('The lower one is %d' % MINIMUM(a,b))

总结：lambda是一个创建简单函数的方法。函数体只能实现单一的功能，即一行表达式，一般没什么用。

5. 查看内置函数的方法

查看文档方法为__doc__，以abs为例，abs.__doc__。

print(abs.__doc__)

def square(num):
    '''Return the square value of the input number.
    The input number must be integer.
    '''
    return num ** 2

print(square.__doc__)

输出：
Return the square value of the input number.
    The input number must be integer.

6. python生成随机数

python中生成随机数主要使用random模块和numpy库中的random函数。

前者主要用于生成随机数和实现序列中随机数和随机数列的挑选，后者用来生成a*b维的随机矩阵。

这里简要叙述以下，详见博客：http://(58条消息) 【python编程】-python生成随机数_杨的博客-CSDN博客

(链接好像没用，不知道为啥)即本系列另一篇博客：python生成随机数。

（1）random.random()：随机生成一个[0, 1)的浮点数

（2）random.uniform(a, b)：随机生成一个[a, b)的浮点数

（3）random.randint(a, b)：随机生成一个[a, b)的整数

（4）random.randrange(a, b, step)：在随机生成的以<以a为始，每step递增，以b为终>这样的一个整数序列中随机选择一个数

（5）random.choice(sequence)：从一个已有的sequence中随机选择一个元素

（6）random.sample(sequence,k)：从某一序列中获取指定长度的片段（随机选取K个，没有顺序）

（7）random.shuffle(列表)：打乱一个列表的元素顺序（打乱的是列表本身，无返回值）

（8）np.random.randn(a, b)：生成a*b维的随机数，且该数服从标准正太分布（可以有若干个参数）

（9）random.randint(low,high,size)：生成一个<以low为下限，high为上限，size大小>的随机整数矩阵，其中数值范围包含low，不包含high

7. 输出方式sys.stdout.write()方法

print方法默认输出完后打印换行，而stdout.write()方法输出不带换行，相当于C++中的printf函数。

from sys import stdout
for i in range(10):
    for j in range(i + 1):
        stdout.write(str(a[i][j]))
        stdout.write(' ')
    print()

输出：
1 
1 1 
1 2 1 
1 3 3 1 
1 4 6 4 1 
1 5 10 10 5 1 
1 6 15 20 15 6 1 
1 7 21 35 35 21 7 1 
1 8 28 56 70 56 28 8 1 
1 9 36 84 126 126 84 36 9 1

8. 关于time库的一些使用

（1）暂停输出函数sleep()

time.sleep(sec)方法，使得屏幕输出晚sec秒的时间。

（2）格式化输出时间time.strftime()

使用time库中的localtime得知当前时间，再使用time.strftime( format, t)。format是格式，参数t是结构化的时间字符串。

import time
print(time.localtime())
print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()))

输出：
time.struct_time(tm_year=2021, tm_mon=9, tm_mday=15, tm_hour=19, tm_min=33, tm_sec=6, tm_wday=2, tm_yday=258, tm_isdst=0)
2021-09-15 19:33:06

9. python中定义类class

python中的类主要包含以下几部分：类变量，实例变量，构造方法__init__，（实例）方法。

类变量属于类本身，用于定义该类本身所包含的状态数据，而实例变量属于该类的对象，用于定义对象所包含的数据；方法用于定义该类对象的行为或功能实现。

在类中定义的方法默认是实例方法，定义实例方法的方法与定义函数的方法基本相同，只是实例方法的第一个参数会被绑定到方法的调用者（该类的实例），因此实例方法至少应该定义一个参数，该参数通常会被命名为 self。

在实例方法中有一个特别的方法：__init__，这个方法被称为构造方法。构造方法用于构造该类的对象，Python 通过调用构造方法返回该类的对象（无须使用 new）。

class Person :
    '这是一个学习Python定义的一个Person类'
    # 下面定义了一个类变量
    hair = 'black'
    def __init__(self, name = 'Charlie', age=8):
        # 下面为Person对象增加2个实例变量
        self.name = name
        self.age = age
    # 下面定义了一个say方法
    def say(self, content):
        print(content)

obj1=Person(name='wood',age=10) 
print(obj1.hair)
print(obj1.name)
print(obj1.age)
obj1.say('hello')

obj2=Person()
print(obj2.hair)
print(obj2.name)
print(obj2.age)
obj2.say('world')

总结：

（1）注意区分以下两类变量即可，类变量是属于类的，实例变量是属于对象的，定义属于此类的对象时要使用构造方法__init__来定义，并传入实例变量参数进行构造该对象；

（2）所有的方法定义时都至少有一个传入参数，即self，被绑定到方法的调用者；

（3）定义类对象时，如果传入参数就按照传入的参数进行赋值，没有参数就取默认值。所以对于类中的构造方法__init__一般给变量赋默认值。

10. 关于函数if name== 'main'

（1）执行过程和结果

一个python文件通常有两种执行方法，一种是作为脚本直接运行，第二种是import到其他的python脚本中被调用（模块重用）执行。因此 if __name__ == '__main__' 就是控制这两种情况的代码执行过程。

重点来了：在 if __name__ == '__main__' 的控制下的代码只有第一种情况（即作为脚本）运行时才会被执行，而import到其他模块中是不会执行的。举例如下：

practice模块：

print('hello world')

if __name__=='__main__':
    print('good morning')

直接执行：

输出：
hello world
good morning

test模块：

import parctice

执行test模块：

hello world

可以看到，直接执行时输出了两行，调用执行时输出了一行。说明调用执行时没有执行if判断条件内的部分。说明判断条件内的部分不成立。

（2）if __name__ == '__main__' 的工作原理

每个python模块包含内置变量 __name__，模块被直接执行时，__name__等于文件名（包含后缀.py）；import到其他模块执行时，__name__等于被调用的模块名称（不包含后缀.py）。

而 “__main__” 始终指向当前执行模块的名称（包含后缀.py），进而当模块被执行时，__name__ == '__main__' 的判断结果为真，所以执行；当调用执行时，判断结果为假，所以不执行。

具体试验方法可以在程序中输出__name__名字进行检验，这里不再赘述。

11. python调用另一个模块的类和方法

（1）在同一个文件夹下

调用函数：直接导入模块或者导入方法使用

Add.py文件：

print('hello world')
def add(a,b):
    print(a+b)

B.py文件：

方法1：
from Add import add
add(1,2)

方法2：
import Add as A
A.add(1,2)

输出：
hello world
3

调用类：相同的方法，导入并且定义类，使用即可

Add.py文件：

class A:
    def __init__(self,xx,yy):
        self.x=xx
        self.y=yy
    def add(self):
        print("x和y的和为：%d"%(self.x+self.y))

B.py文件：

from A import A
a=A(2,3)
a.add()

或者

import A
a=A.A(2,3)
a.add()

（2）在不同文件夹下

A.py文件的文件路径：E:\PythonProject\winycg

B.py文件：使用sys库的sys.path()方法

import sys
sys.path.append(r'E:\PythonProject\winycg')
'''python import模块时， 是在sys.path里按顺序查找的。
sys.path是一个列表，里面以字符串的形式存储了许多路径。
使用A.py文件中的函数需要先将他的文件路径放到sys.path中'''
import A
 
a=A.A(2,3)
a.add()

注意：可以看到，无论导入方法还是直接导入整个模块，被导入的模块都是执行了一遍的，即输出了该模块的东西，所以一般要导入的模块只作为功能模块，里边写各种方法准备进行调用，而不应写实际的操作。

12. 生成器yield

生成器yield：yield简要可以当一个return来理解，带有生成器的函数叫做生成器函数。当调用生成器函数遇到yield时，就从此步返回生成的值，并返回原函数继续执行，当下一次再调用该生成器函数，就从上次返回的地方接着执行，不用再从头执行。

（1）一个带有yield的函数就是一个生成器，它跟函数不同，生成一个生成器看起来像函数调用，但不会执行任何函数代码，只有在for循环中执行next时才开始执行；

（2）执行流程仍然按照函数的执行流程执行，但每执行一个yield语句都会中断，返回一个迭代值，下次执行从yield的下一条语句执行；

（3）看起来就像函数执行过程中被yield中断了数次，每次中断都会通过yield返回当前的迭代值；

示例：

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

f = fib(6)
for i in f:
    print(i)

优点：

生成器更节省存储空间，响应速度更快，使用更灵活。普通写法是全部生成再处理，生成器是生成一个使用一个，然后立马删掉。

昔我往矣wood

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【python编程】-入门系列知识点总结

本篇博客写前三篇文章：入门系列1、2和3的知识点详细总结和介绍。1. 创建二维矩阵的方法主要有以下几种：l1=[[0 for i in range(3)] for j in range(3)]for i in range(3): for j in range(3): l1[i][j]=i*jprint(l1)l2=[[] for i in range(3)]for i in range(3): for j in range(3): l2
复制链接

扫一扫