Python_基础笔记

Posted 2020-06-15

查看类信息:

Dir(类)     help(类)

Nl 是List

print nl.count(5)   # 计数，看总共有多少个5

print nl.index(3)    # 查询 nl 的第一个3的下标, n1.index(3,2)表示3第二次出现的位置

nl.append(6)         # 在 nl 的最后增添一个新元素6

nl.sort()           # 对nl的元素排序

print nl.pop()       # 从nl中去除最后一个元素，并将该元素返回。

nl.remove(2)         # 从nl中去除第一个2

nl.insert(0,9)       # 在下标为0的位置插入9

nl.extend(list)  #追加list，即合并list到nl上

 

dic是字典(dictionary)

dic ={‘tom‘:11, ‘sam‘:57,‘lily‘:100}

dic[‘lilei‘] = 99  #添加或修改元素

del dic[‘tom‘]        # 删除 dic 的‘tom’元素

print dic.keys()     # 返回dic所有的键

print dic.values()    # 返回dic所有的值

print dic.items()     #返回dic所有的元素（键值对）

dic.clear()           #清空dic，dict变为{}

len(dic)              #查询词典中的元素总数

 

遍历字典:

for key in dic:
    printdic[key]

 

操作文件:

F = open(name, "r")#‘w‘:只写,‘r‘:只读
line =f.readline()
f.write(‘abc‘)
f.close()

 

引用模块:

import a asb                        #引入模块a，并将模块a重命名为b

from a import function1 # 从模块a中引入function1对象。调用a中对象时，我们不用再说明模块，即直接使用function1，而不是a.function1。

from a import*                        #从模块a中引入所有对象。调用a中对象时，我们不用再说明模块，即直接使用对象，而不是a.对象。

 

Python会在以下路径中搜索它想要寻找的模块：

程序所在的文件夹

操作系统环境变量PYTHONPATH所包含的路径

标准库的安装路径

 

模块包

可以将功能相似的模块放在同一个文件夹（比如说this_dir）中，构成一个模块包。通过

importthis_dir.module

引入this_dir文件夹中的module模块。

该文件夹中必须包含一个__init__.py的文件，提醒Python，该文件夹为一个模块包。__init__.py可以是一个空文件。

 

模块导入:

#from testmodule import first     #推荐用法
import testmodule.first     #需要添加__init__.py文件.内容为:__all__ = ["home", "wolf","testmodule"]
for i inrange(10):
testmodule.first.laugh(i)

 

包裹传递的关键在于定义函数时，在相应元组或字典前加*或**

参数dict是包裹关键字传递所用的字典，在dict前加**。

*和**，也可以在调用的时候使用，即解包裹(unpacking)

参数传递的基本原则是，先位置，再关键字，再包裹位置，再包裹关键字

 

range(startIndex,lengh,step)  #开始坐标,长度,间隔)

enumerate()函数，可以在每次循环中同时得到下标和元素:

for(index,char) in enumerate(S):

 

zip()函数的功能，就是从多个列表中，依次各取出一个元素。每次取出的(来自不同列表的)元素合成一个元组，合并成的元组放入zip()返回的列表中。zip()函数起到了聚合列表的功能

Eg:

ta =[1,2,3]
tb =[9,8,7]
 
# cluster
zipped =zip(ta,tb)
print(zipped)
 
#decompose
na, nb =zip(*zipped)
print(na,nb)

 

# -*- coding: utf-8 -*-斐波那契數列

#0, 1, 1,2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233

class FN:
    def __init__(self,index):
        if index < 1:
           self.fnList.append(0)
        else:
            whilelen(self.fnList)< index:
               self.fnList.append(0)
       self.fibonacciNumberList(index)
   
    fnList = []
    deffibonacciNumberList(self, index):
        if index < 2:
            self.fnList[0] = 0
            return 0
        elif index == 2:
            self.fnList[index- 1] = 1
            return 1
        else:
           self.fnList[index-1] = self.fibonacciNumberList(index-1) +self.fibonacciNumberList(index -2)
            returnself.fnList[index-1]

class FN:
    def fibonacciNumberList(self, index):
        if index < 2:
            return 0
        elif index == 2:
            return 1
        else:
            returnself.fibonacciNumberList(index-1) + self.fibonacciNumberList(index -2)

 

生成器表达式(GeneratorExpression):

G =(x for x inrange(4))

 

表推导(list comprehension)是快速生成表的方法

表推导(每个元素的多少次方)

L = [x**2 for x in range(10)]   # 从0到10 ,每个元素的2次方

 

综合例子:

xl= [1,3,5]
yl = [9,12,13]
L  = [ x**2 for(x,y) in zip(xl,yl) ify > 10]

 

lambda函数

func= lambda x,y: x + y

printfunc(3,4)

可改写为:

def func(x, y):
    returnx + y
 
try:... except exception: ... else: ... finally: ...
raise exception   ---- 主动抛出异常

def test_func():
    try:
        m = 1/0
    except NameError:
        print("Catch NameError in the sub-function")
try:
    test_func()
exceptZeroDivisionError:
    print("Catch error in the main program")

动态类型的核心:引用和对象的分离，对象是内存中储存数据的实体，引用指向对象。

Python会自动将没有引用指向的对象销毁(destruct)，释放相应内存。

(对于小的整数和短字符串，Python会缓存这些对象，而不是频繁的建立和销毁。)

 

即使是多个引用指向同一个对象，如果一个引用值发生变化，那么实际上是让这个引用指向一个新的引用，并不影响其他的引用的指向。从效果上看，就是各个引用各自独立，互不影响。

 

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

而像之前的数字和字符串，不能改变对象本身，只能改变引用的指向，称为不可变数据对象(immutableobject)。

元组(tuple)，尽管可以调用引用元素，但不可以赋值，因此不能改变对象自身，所以算是immutable object.

本文出自 “狼之魂” 博客，请务必保留此出处http://itwolf.blog.51cto.com/3286625/1744152