Python进阶学习

Python中的访问限制

'''
私有属性是以双下划线'__'开头的属性，在类的外部访问私有属性将会抛出异常，提示没有这个属性。
'''

class Animal:
    __location='china'
    def __init__(self,name,age):
        self.name=name
        self.__age=age

#__location是类的私有属性，在class外部无法直接访问
print(Animal.__location)
dog=Animal('dog',3)
print(dog.name)
#__age是对象的私有属性，在class外部无法直接访问
print(dog.__age)

 Python中的类方法

'''
类方法：
1、类方法需要使用@classmethod来标记为类方法，否则定义的还是实例方法
2、类方法的第一个参数将传入类本身，通常将参数名命名为 cls
'''
class Animal:
    __count=0 #私有的类属性，每创建一个实例对象，该值就加1
    def __init__(self):
        Animal.__count+=1

    @classmethod
    def get_count(cls):
       return cls.__count
    @classmethod
    def set_count(cls,count):
        cls.__count=count

Animal.set_count(0)
dog1=Animal()
dog2=Animal()
dog3=Animal()
dog4=Animal()
print(Animal.get_count())

 Python判断类型

s = 'this is a string.'
print(isinstance(s, int) )#False
print(isinstance(s, str) )#True

Python的多重继承

'''
python支持多重继承
'''
class First(object):
    def __init__(self):
        super(First, self).__init__()
        print("first init...")

class Second(object):
    def __init__(self):
        super(Second, self).__init__()
        print("second init...")

class Third(First, Second):
    def __init__(self):
        super(Third, self).__init__()
        print("third init...")

Third()
'''
输出结果：
second init...
first init...
third init...
'''

Python类的__slots__方法

 

Python类的__call__方法

'''
如果把一个类的实例也变成一个可调用对象，可以实现一个特殊的方法__call__()
'''
class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

    def __call__(self, friend):
        print('My name is {}...'.format(self.name))
        print('My friend is {}...'.format(friend))

p=Person('zhangsan','nan')
p('lisi')

'''
输出的结果为：
My name is zhangsan...
My friend is lisi...
'''

 Python安装第三方模块

Python读写文件

# input函数：通过命令行界面输入东西
str=input('please input biao da shi:')
# eval函数：将算术表达式计算出结果
print(eval(str))
'''
运行结果如下：
please input biao da shi:7*8
56
'''

 

'''
请尝试以只读模式打开一个指定绝对路径的文本文件，并正确关闭。
'''
def open_text_file():
    #默认打开的就是文本文件
    f=open('E:\\test\\nginx.conf','r')
    print(type(f))
    f.close()

'''
请尝试用只读模式打开一个指定绝对路径的二进制文件，并正确关闭
'''
def open_binary_file():
    f=open('E:\\test\\my_love.jpg','rb')
    print(type(f))
    f.close()

 

'''
读取文件的内容，文件的内容被原样打印出来
'''
def read_text_file():
    #默认打开的就是文本文件
    f=open('E:\\test\\nginx.conf','r',encoding='utf8')
    #readlines()会读到换行符\n，且该函数返回的结果是list
    for line in f.readlines():
        line=line.strip('\n') #去调换行符\n
        print(line)
    f.close()

 

'''
请从test.txt文件读取以上内容，并将每一行字符串反转，写入test1.txt文件
test.txt文件中的原内容：
Hello World
Hello Python
Hello Imooc
test1.txt文件中的预期内容：
dlroW olleH
nohtyP olleH
coomI olleH
'''
def write_text_file(src_file,dest_file):
    f1=open(src_file,'r',encoding='utf8')
    f2=open(dest_file,'w',encoding='utf8')
    lines=f1.readlines() #lines为['Hello World\n','Hello Python\n','Hello Imooc']
    num=0 #用来记录行数
    for line in lines:
        #读一行，行数记录加1
        num+=1
        line=line.strip('\n')[::-1] # 去掉\n后反转字符串
        f2.write(line)
        #最后一行的后面不写换行符
        if num!=len(lines):
            f2.write('\n')
    f1.close()
    f2.close()

 

'''
test.txt文件中的内容如下：
Hello World
Hello Python
Hello Imooc
请将文件的内容重复写一份追加到文件的尾部。
'''
# seek()函数参数的含义如下，0：文件首部，1：当前位置，2：文件尾部
def append_text_file(src_file):
    f=open(src_file,'a+')
    f.seek(0)
    contents=f.readlines()
    print(contents)
    # 本身最后一行没有换行符，先移动到文件尾部增加一个换行符
    f.seek(2)
    f.write('\n')
    # 再次移动到文件的尾部
    f.seek(2)
    f.writelines(contents)
    f.close()

 

'''
使用with关键字：
with关键字对资源进行访问的场合，会确保不管在使用过程中是否发生异常，都会执行必要的“清理”的操作，释放资源，比如文件使用后自动关闭等等
当文件使用结束后，不需要显式的调用f.close()关闭文件。
'''
def with_append_text_file(src_file):
    with open(src_file,'a+') as f:
        f.seek(0)
        contents=f.readlines()
        print(contents)
        # 本身最后一行没有换行符，先移动到文件尾部增加一个换行符
        f.seek(2)
        f.write('\n')
        # 再次移动到文件的尾部
        f.seek(2)
        f.writelines(contents)

 

Python网络编程

通过socket实现网络通信

import socket
'''
服务端在收到消息后，也把消息原样返回给client
'''
# 1. 新建socket
server = socket.socket()
# 2. 绑定IP和端口（其中127.0.0.1为本机回环IP）
server.bind(('127.0.0.1', 8999))
# 3. 监听连接
server.listen(5)
# 4. 接受连接(返回一个新的socket和一个address:ip和端口号)
s, addr = server.accept()
print('connect addr：{}'.format(addr))
# 5. 接收客户端的内容，并原样返回给客户端
while True:
    content =s.recv(1024)
    if str(content,encoding='utf-8')=='end':
        break
    if len(content)!=0:
        print('客户端发送给我的内容：{}'.format(str(content,encoding='utf-8')))
        s.send(content)
s.close()

import socket
'''
client.py可以循环接收用户输入并发送给服务端
'''
# 1. 新建socket
client = socket.socket()
# 2. 连接服务端（注意，IP和端口要和服务端一致）
client.connect(('127.0.0.1', 8999))
# 3. 发送内容，注意发送的是字节字符串。
while True:
    content=input('>>>')
    client.send(bytes(content, encoding='utf-8'))
    # 当向服务端发送end字符串时，表示我要断开与服务端的连接
    if content=='end':
        break
    recvStr=str(client.recv(1024),encoding='utf-8')
    print(f'服务端返回给我的内容：{recvStr}')
client.close()

 

通过http实现网络通信

 

'''
Python提供了相关的库urllib，通过urllib包里面的request，可以向其他HTTP服务器发起请求
'''
from urllib import  request

response=request.urlopen('http://baidu.com')
# 打印出响应头信息
print('响应头信息如下：')
for k,v in response.getheaders():
    print(f'{k}:{v}')
# 打印出响应状态码
print(f'响应状态码：{response.status}')

 

'''
使用第三方库requests
'''
import requests

response=requests.request(method='GET',url='https://www.imooc.com/')
print('响应头信息如下：')
print(response.headers)
print(f'响应状态码：{response.status_code}')
print('响应内容如下：')
content = str(response.content, encoding='utf-8')
print(content)
print('响应内容中链接含有www的内容：')
content_list = content.split('\n')
for line in content_list:
    if 'www' in line:
        print(line.strip())

 

Python函数式编程

import math

'''
Python把函数作为参数
'''
def add(x,y,f):
    return f(x)+f(y)
print(add(4,25,math.sqrt))

'''
map()函数：
map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f依次作用在list的每个元素上
map()的使用方法：map(f,list)
map()函数会返回一个迭代器，可以依次迭代得到原来list的元素被函数f处理后的结果。

请利用map()函数，把一个list（包含若干不规范的英文名字）变成一个包含规范英文名字的list：
输入：['alice', 'BOB', 'CanDY']
输出：['Alice', 'Bob', 'Candy']
'''
# 将一个字符串的首字符变成大写，其它字符变成小写
def f(str):
    return str[0].upper() + str[1:].lower()

str_list=['alice', 'BOB', 'CanDY']
print([item for item in map(f,str_list)])

'''
reduce()函数：
reduce()函数接收的参数和 map() 类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值
在python3中，reduce()函数被收录到functools包内，需要引入functools才可以使用
reduce()还可以接收第3个可选参数，作为计算的初始值

Python内置了求和函数sum()，但没有求积的函数，请利用recude()来求积
输入：[1, 3, 5, 7, 9]
输出：13579的结果
'''
from functools import reduce
def f(x,y):
    return x*y
list=[1, 3, 5, 7, 9]
print(reduce(f,list))

'''
filter()函数是 Python 内置的另一个有用的高阶函数
filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，
filter()根据判断结果自动过滤掉不符合条件的元素，并返回一个迭代器，可以迭代出所有符合条件的元素。

请利用filter()过滤出1~100中平方根是整数的数，即结果应该是：1, 4, 9, 16, 25, 36, 49, 64, 81, 100。
'''
import math
def sqrt_is_int(x):
    return int(math.sqrt(x))**2==x
print([item for item in filter(sqrt_is_int,range(1,101))])

'''
 sorted()函数:
 是Python内置的函数
 sorted()接受key参数，用来指定排序的字段，key的值是一个函数，接受待排序列表的元素作为参数，并返回对应需要排序的字段
 如果需要倒序，指定reverse参数即可

对字符串排序时，有时候忽略大小写排序更符合习惯。请利用sorted()高阶函数，实现忽略大小写排序的算法。
输入：['bob', 'about', 'Zoo', 'Credit']
输出：['about', 'bob', 'Credit', 'Zoo']
'''
# 方法1
def func1():
    s = ['bob', 'about', 'Zoo', 'Credit']
    print(sorted(s,key=lambda w:w.lower()))

# 方法2
def f(str):
    return str.lower()

def func2():
    s = ['bob', 'about', 'Zoo', 'Credit']
    print(sorted(s, key=f))

func1()
func2()

'''
Python返回函数
请编写一个函数calc_prod(list_)，它接收一个list，返回一个函数，返回函数可以计算参数的乘积。
'''
def calc_prod(list_):
    def product():
        res=1
        for item in list_:
            res=res*item
        return res
    return product

product=calc_prod([1,2,3,4])
print(product())

'''
Python的闭包
像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）
返回函数不要引用任何循环变量，或者后续会发生变化的变量
'''
def calc_sum(list_):
    def lazy_sum():
        return sum(list_)
    return lazy_sum
'''
请写count()函数，让它正确返回能计算1x1、2x2、3x3的函数
'''
def count(x,y):
    def f():
        return x*y
    return f

for i in range(1,4):
    f=count(i,i)
    print(f())

'''
Python的匿名函数
定义方式：使用lambda定义，例如lambda x: x * x，冒号前面的x表示匿名函数的参数，后面的是一个表达式
匿名函数有个限制，就是只能有一个表达式，不写return，返回值就是该表达式的结果

请利用sorted()高阶函数和lambda匿名函数，实现忽略大小写排序的算法。
输入：['bob', 'about', 'Zoo', 'Credit']
输出：['about', 'bob', 'Credit', 'Zoo']
'''
print(sorted(['bob', 'about', 'Zoo', 'Credit'],key=lambda str:str.lower()))

'''
Python的装饰器decorator
本质上就是一个高阶函数，它接收一个函数作为参数，然后，返回一个新函数。
请编写一个@performance，它可以打印出函数调用的时间。
'''
import time

#不带参数的装饰器performance
def performance(f):
    def print_time(*args, **kwargs):
        start=time.time()
        print('call ' + f.__name__ + '()')
        r=f(*args, **kwargs)
        end=time.time()
        print(f'函数{f.__name__}()执行的时间为：{end-start}')
        return r
    return print_time

#使用装饰器performance
@performance
def my_task():
    for i in range(1,100001):
        print(i)

#函数调用开始
my_task()

'''
带参数的装饰器：打印函数名称
'''
def log(prefix):
    def log_decorator(f):
        def wrapper(*args, **kw):
            print('[{}] {}()...'.format(prefix, f.__name__))
            return f(*args, **kw)

        return wrapper

    return log_decorator

# 使用log装饰器
@log('DEBUG')
def test():
    pass
# 函数调用
test()

# 另一个带参数的装饰器
import time

def performance(unit):
    def perf_decorator(f):
        def fn(*args, **kw):
            t1 = time.time()
            r = f(*args, **kw)
            t2 = time.time()
            t = (t2 - t1) * 1000 if unit == 'ms' else (t2 - t1)
            print('call {}() in {}{}'.format(f.__name__, t, unit))
            return r

        return fn

    return perf_decorator


@performance('ms')
def my_task():
    print([i for i in range(1,100001)])

#函数调用
my_task()

'''
Python的偏函数
偏函数指的就是“创建一个调用另外一个部分参数或变量已经预置的函数”的函数的用法
functools.partial就是帮助我们创建一个偏函数的

在前面，我们在sorted这个高阶函数中传入自定义排序函数就可以实现忽略大小写排序。
请用functools.partial把这个复杂调用变成一个简单的函数
'''
import functools

sorted_ignore_case = functools.partial(sorted, key=lambda item: item.lower())
print(sorted_ignore_case(['bob', 'about', 'Zoo', 'Credit']))