python笔记2

最新推荐文章于 2024-02-10 17:11:54 发布

sinat_41652408

最新推荐文章于 2024-02-10 17:11:54 发布

阅读量173

点赞数

分类专栏： python笔记

本文链接：https://blog.csdn.net/sinat_41652408/article/details/100868299

版权

python笔记专栏收录该内容

3 篇文章 0 订阅

订阅专栏

第五章.函数

5.闭包

如果一个内部函数里，对在外部作用域（但不是全局作用域）的变量进行引用，那么内部函数就被认为是闭包：

def funx(x):
    def funy(y)
        return x*y
    return funy

i = funx(8)
i = (5)             # >>> 40

funx(8)(5)          # >>> 40

如果希望在内部函数里可以修改外部函数里局部变量的值，可用关键字nonlocal，其用法与global相同

def funx():
    x = 5
    def funy():
        nonlocal x
        x *= x
        return x
    return funy()

funx()              # >>> 25

6.lambda、filter、map

# lambda语句：
def add(x,y):
    return x+y
add(1,2)                # >>> 3

z = lambda x,y : x+y
z(1,2)                  # >>> 3

# filter
#temp = filter("条件语句",[需要被筛选的列表])
temp = filter(None,[-1,0,1,2])
list(temp)                      # >>> [1,2]

def fun(x)
    return x%2

temp = filter(fun,range(10))    #筛选出fun(x)=True 的数
list(temp)                      # >>> [1,3,5,7,9]


# map
temp = map(lambda x:x*2 , range(5))#将列表里的每个数都进行 x*2 的操作，然后将结果返回
list(temp)                      # >>> [0,2,4,6,8]

7.递归

递归，从原理上看就是某函数调用了自身的一个行为。

#阶乘：
def fun1(n):
    if n == 1:
        return 1
    else:
        return n*fun1(n-1)
m = fun1(5)
print(m)                    # >>> 120 (5*4*3*2*1 = 120)

#汉诺塔：
def hanoi(n,x,y,z):
    if n == 1:
        print(x,'-->',z)
    else:
        hanoi(n-1,x,z,y)    #将前n-1个盘子从x移动到y上
        print(x,'-->',z)    #将最底下的最后一个盘子从x移动到z上
        hanoi(n-1,y,x,z)    #将y上的n-1个盘子移动到z上

n = int(input('请输入汉诺塔的层数：'))
hanoi(n,'X','Y','Z')

第六章.字典和集合

1.字典

字典把这个字（或单词）成为"Key"，其对应的含义成为"Value"，有些地方称字典为哈希(hash)或者是关系数组。

#使用大括号创建字典，将Key与Value用 : 隔开
dict1 = {"A":1,"B":2,"C":3}
print("索引A的值",dict1["A"])       # >>>索引A的值 1

#通过查找Key可对Value进行操作
dict1["A"] = 'a'
dict1["B"] = 'b'
dict1["C"] = 'c'
dict1                               #{"A":"a","B":"b","C":"c"}

dict1["D"] = 'd'
dict1.setdefauult('E','e')
dict1                               #{"A":"a","B":"b","C":"c","D":"d","E":"e"}

2.对于字典的各种内置方法

#创建并返回一个新的字典，有2个参数，1是Key，2是Value
dict1 = {}
dict1.fromkeys((1,2,3),'N')
dict1                               # >>>{1:'N',2:'N',3"'N'}

dict1.clear()
dict1 = {"A":1,"B":2,"C":3}
dict1.keys()                        # >>>dict_keys(['A', 'B', 'C'])
dict1.values()                      # >>>dict_values([1, 2, 3])
dict1.items()                       # >>>dict_items([('A', 1), ('B', 2), ('C', 3)])

dict1.get('A')                      # >>> 1
'B' in dict1                        # True

3.集合

集合中的元素是唯一的、无序的，不能索引

#创建集合
set1 = {1,2,3}
set2 = set([1,2,3,3,3])
set2                                # >>>{1,2,3}

#去除列表中重复元素
num = [1,2,3,4,5,6,5,4,1,2]
temp = []
for i in num:
    if i not in temp:
        temp.append(i)
temp                                # >>>[1,2,3,4,5,6]
#   or
num = list(set(num))

#增加集合中的元素
set1.add(4)

#删除集合中的元素
set1.remove(1)

#定义一个不可变的集合
set3 = frozenset([1,2,3,4,5])

第七章.文件

1.打开文件

open()函数可用于打开一个文件，并返回文件对象,其语法是：

open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

file:文件路径
mode:文件打开模式
buffering:设置缓冲
encoding:文本编码，一般使用utf8
errors:报错级别
newline：区分换行符
closefd:传入的file参数类型

[外链图片转存失败(img-hVtBoDB0-1568562122755)(pic/python_4.png ‘mode参数’)]

2.file对象方法

文件对象方法	执行操作
f.close()	关闭文件
f.read(size = -1)	从文件读取size个字符。当size给负值或不写时，读取所有的字符
f.readline()	以写入模式打开，如果文件存在，则在末尾追加写入
f.write(str)	将字符串str写入文件
f.writelines(seq)	向文件写入字符串学列seq，seq应该时一个返回字符串的可迭代对象
f.seek(offset,from)	在文件中移动文件指针，从from（0代表文件起始位置，1代表当前位置，2代表文件末尾）便宜offset个字节
f.tell()	返回当前文件中的位置

3.文件系统

#获得应用程序当前的工作目录
import os
os.getcwd()         # 返回当前工作路径
#改变工作目录
os.chdir('E:\\')
#列举出当前目录下有哪些文件和子目录
os.listdir('E:\\')
#创建一个文件夹
os.mkdir('E:\\A')   #在E盘新建文件夹A
os.mkdir('E:\\A\\B')#在文件夹A下面再创建文件夹B    
#删除文件、目录、多层目录
os.remove('E:\\A\\1.txt')
os.rmdir('E:\\A\\B')
os.removedirs('E:\\A')
#重命名文件
os.rename('E:\\A\\1.txt','E:\\A\\2.txt')  #将文件夹A中1.txt重命名为2.txt
#运行系统shell命令
os.system('CMD')        #打开控制命令窗口
os.system('calc')       #打开计算器

os.listdir(os.curdir)   #列出当前目录下的文件夹名称

函数名	使用方法
basename(path)	去掉目录路径，单独返回文件名
dirname(path)	去掉文件名，单独返回目录路径
join(path1[,path2[,]])	将path1，path2各部分组合成一个路径名
split(path)	分割文件名与路径，返回（f_path,f_name）元组。如果完全使用目录，他也会将最后一个目录作为文件名分离，且不会判断文件或者目录是否存在
splitext(path)	分离文件名与扩展名，返回（f_name,f_extension）元组
getsize(file)	返回指定文件的尺寸，单位是字节
getatime(file)	返回指定文件最近访问时间(浮点型秒数，可用time模块的gmtime()或localtime()函数换算)
getctime(file)	返回指定文件的创建时间
getmtime(file)	返回指定文件最新的修改时间

4.pickle

该模块可以将列表、字典等复杂数存储为二进制文件（拓展名.pkl或者.pickle）

#保存数据
import pickle
my_list = [123,3.14,'abc',['another list']]
pickle_file = open('my_list.pkl','wb')
pickle.dump(my_list,pickle_file)
pickle_file.close()
#加载数据
pickle_file = open('my_list.pkl','rb')
my_list2 = pickle.load(pickle_file)
print(my_list)      # >>>[123,3.14,'abc',['another list']]

第九章.图形界面：EastGui

[小甲鱼翻译改编教学文档]https://blog.csdn.net/qiaoermeng/article/details/99718378

第十章.类和对象

数据和代码封装在一起形成一个对象

对象 = 属性(对象的特征) + 方法(对象的方法)
用类 (class) 来定义对象的属性和方法

class Turtle:
    #属性
    color = 'green'
    weight = 10
    legs = 4
    shell = True
    mouth = '大嘴'
    #方法
    def climb(self):
        print('爬')
    def run(self):
        print('跑')

tt = Turtle()
tt.climb()          # >>>爬

1.特征

#继承
class mylist(list):
    pass

list1 = mylist()
list1.append(5)
list1.append(3)
list1               # >>>[3,5]

#多态
class A:
    def fun(self):
        print('aaa')

class B:
    def fun(self):
        print('bbb')

a = A()
b = B()

a.fun()         # >>> 'aaa'
b.fun()         # >>> 'bbb'

2.面向对象编程

self:同一个类可以生成无数对象，当一个对象的方法被调用时，对象会将自身的引用作为第一个参数来引用。

class Ball:
  def setname(self,name):
      self.name = name
  def  kick(self):
      print('我叫%s' % self.name)
a = Ball()
a.setname('HA')
b = Ball()
b.setname('HB')
a.kick()           # >>> 我叫HA
b.kick()           # >>> 我叫HB

__init__():构造方法。这个方法在对象创建时会自动调用；实例化对象的传入参数会自动传入 __init__()

class potato:
  def __init__(self,name):
      self.name = name
  def kick(self):
      print("%s" % self.name)
p = potato("土豆")
p.kick()           # >>> 土豆

共有私有：默认上对象的属性和方法都是公开的，可以直接通过点操作(.)来访问。

class person:
  name = 'HB'
p = person()
p.name()           # >>> HB

定义私有变量只需要在变量名或者函数名前面加上"__"双下划线即可

class person:
  __name = 'Hb'
  def getname(self):
      return self.__name
p = person()
p.getname()        # >>> Hb （使用p.__name()会报错说变量未定义）
p.person__name     # >>> Hb

父类子类继承：
子类可继承父类的属性和方法，语法：

class 类名(被继承的类)：
    ...

例：

class parent:
    def hello(self):
        print("父类")

class child(parent):
    pass

p = parent()
p.hello()           # >>> 父类
c = child()
c.hello()           # >>> 父类

class child(parent):
    def hello(self):
        print("子类")

c = child()
c.hello()           # >>> 子类

子类需要调用父类的构造方法时，不重写__init__，就可以自动调用父类所定义的__init__；若子类重写了__init__，则会覆盖父类所定义过的语句：

class parent(object):
    def __init__(self,name):
        self.name = name
        print("name:%s" % (self.name))
    def getName(self):
        return 'parent' + self.name

class child(parent):
    def getName(self):
        return 'child' + self.name

if __name__ == '__main__':
    child = child('runoob')
    print( child.getName() )

#输出结果： name:runoob
#          child:runoob 

class child(parent):
    def __init__(self,name):
        print("hi")
        self.name = name
    def getName(self):
        return 'child'+self.name

if __name__ == '__main__':
    child = child("runoob")
    print( child.getName() )

#输出结果：  hi
#           child runoob

倘若重写了__init__，又要继承父类的构造方法，需要用到super关键字，或者在子类__init__中写入父类的引用：

super(子类,self).__init__(参数1,参数2,...)

#例：
class parent(object):
    def __init__(self,name):
        self.name = name
        print( "name:%s" %(self.name))
    def getName(self):
        return 'parent' + self.name

class child(parent):
    def __init__(self,name):
        super(child,self).__init__(name)    #或：parent.__init__(self)
        print("hi")
        self.name = name
    def getName(self):
        return 'child' + self.name

if __name__ == '__main__':
    child = child('runoob')
    print( child.getName() )

#输出结果： name:runoob
#          hi
#          child runoob

多重继承：只需要在定义子类的时候，内部参数生命多个父类。

组合：
将需要的类放进去实例化，就是组合。

#创建一个有乌龟和鱼的水池：
class turtle:
    def __init__(self,x):
        self.num = x

class fish:
    def __init__(self,x):
        self.num = x

class pool:
    def __init__(self,x,y):
        self.turtle = turtle(x)
        self.fish = fish(y)
    def print_num(self):
        print("turtle have %d , and fish have %d" % (self.turtle.num,self.fish.num) )

p = pool(1,10)
p.print_num()        # >>> turtle have 1 , and fish have 10

类、类对象和实例对象

class c:
    count = 0

a = c()
b = c()
print(a.count,b.count)  # >>> 0 0

b.count += 10
print(a.count,b.count)  # >>> 0 10

c.count + 100
print(a.count,b.count)  # >>> 100 110

实例对象b的count属性赋值后，覆盖了类对象c的count属性。若没覆盖，则引用了类对象的count属性

相关bif

issubclass(class,classinfo)：如果参数class是参数classinfo的一个子类，则返回True
class A:
   pass
class B(A):
    pass
issubclass(B,A)     # >>> True
isinstance(object,classinfo)：如果参数object是参数classinfo的实例对象，则返回True
hasattr(object,name)：测试对象object是否有属性name（属性的字符串名字）
gerattr(object,name[,default])：返回对象指定的属性值，若不存在则返回default值
setattr(object,name,value)：设置对象中指定属性的值
delattr(object,name)：删除对象中指定的属性
property(fget=None,fset=None,fdel=None,doc=None)：通过属性来设置属性，需要人为配置如何设置属性
class A:
    def __init__(self,size = 10):
        self.size = size
    def getsize(self):
        return self.size
    def setsize(self,value):
        self.size = value
    def delsize(self):
        del self.size
    x = property(getsize,setsize,delsize) #配置好后，.x自动等同.getsize & .setsize & .delsize

… …未完待续

sinat_41652408

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python笔记2

第五章.函数5.闭包如果一个内部函数里，对在外部作用域（但不是全局作用域）的变量进行引用，那么内部函数就被认为是闭包：def funx(x): def funy(y) return x*y return funyi = funx(8)i = (5) # >>> 40funx(8)(5) # ...
复制链接

扫一扫