python学习笔记9-其他

计算x的n次方

def power(x,n):
    s=1
    while n>0:
       n=n-1
       s=s*x
    return s
print(2,4)

计算aa+bb+c*c+……

def calc(*numbers):
    sum=0
    for n i numbers:
       sum=sum+n*n
    return sum
print(calc(2,4,5))

如何在一个函数内部修改全局变量

利用global修改

a=5
def fn():
   global a
   a=4
fun()
print(a)

命令行启动程序并传参python 1.py 22 33 ，则print(sys.argv)会输出什么

#会输出文件明和参数构成的列表
['1.py','22','33']

递归求和

def get_sum(num):
    if num>=1:
	    res=num+get_num(num-1)
	else:
	    res=0
	return res
res=get_num(10)
print(res)

递归的基本的骨架

def recursions(n):
    if n==1:
	    return 1
	return n*recursions(n-1)

python递归深度默认是多少？递归深度限制的原因是什么？

python递归深度可以用内置函数库中的sys.getrecursionlimit()查看。因为无限递归会导致栈溢出和python崩溃

如何判断是函数还是方法

#看它的调用者是谁，如果是类，那么就需要传入一个参数self的值，这是它就是一个函数。如果调用者是对象，那么就不需要给self传入参数值，这时它就是一个方法
print(isinstance(obj.func,FunctionType)) #False
print(isinstance(obj.func,MethodType)) #True
#方法无需传入self参数；函数必须手动传入self参数

打印1~10的数字以及每个数的平方、几何级数和阶乘

from math import factorial
def main():
    print('%-10s%-10s%-10s%-10s'%('数字','平方','几何级数','阶乘'))
    for num in range(1,11):
        print('%-12d%-12d%-12d%-12d'%(num,num**2,2**num,factorial(num)))

if __name__=='__main__':
   main()

统计字符串中英文字母和数字各自出现的次数

import string

def count_letter_number(str1):
    """
    >param string:给定一个字符串
    >return:由字符串中英文字幕和数字各自出现的次数组成的元组 
    """
    m=0#统计英文字母
    n=0#统计数字
    for s in str1:
        if s in string.ascii_letters:
            m+=1
        elif s in string.digits:
            n+=1
    return m,n

def main():
    print(count_letter_number('a1b2c3d4'))  #(4,4)
    print(count_letter_number('a123456b'))  #(2,6)
    print(count_letter_number('123456!!'))  #(0,6)

if __name__=='__main__':
    main()

判断传入的整数列表（要求元素个数大于2）中的元素能否构成等差数列

import string

def is_arithmetic_series(num_list):
    """
    >param num_list:给定判断的列表
    >return:是等差数列返回True，否则返回False
    """

    num_list.sort()
    difference=num_list[1]-num_list[0]
    for x in range(len(num_list)-1):
        if num_list[x+1]-num_list[x] != difference:
            return False
    return True

def main():
    list1 = [1,3,5,7,9]
    list2 = [100,500,200,400,300]
    list3 = [1,2,3,5,6,7]
    print(is_arithmetic_series(list1))
    print(is_arithmetic_series(list2))
    print(is_arithmetic_series(list3))
    print(list2)

if __name__=='__main__':
    main()

计算字符串中所有数字序列的和

import re
def sum_num_seq(string):
    ```
	>param string:
    >return:返回里面数字序列的的和
    ```
    nums=re.compile(r'\d+')
	mylist=nums.findall(string)
	my_sum=0
	for num in mylist:
	    my_sum+=int(num)
	return my_sum

def main():
    print(sum_num_seq('a1b2c3d4'))
    print(sum_num_seq('123hello456good789bye'))
    print(sum_num_seq('12345678'))
    print(sum_num_seq('abcdefgh'))

if __name__=='__main__':
    main()

对传入的字符串（假设字符串中只包含小写字母和空格）进行加密操作，加密的规则是a变d，b变e……空格不变，返回加密后的字符串

import string
def caesar_encrypt(string):
    """
    >param string:给定一个字符串
    >return:返回加密后的字符串
    """
    new_string=''
    all_string=string.ascii_lowercase
    for x in string:
        if x in all_string:
            index=all_string.find(x)
            if index>=len(all_string)-3:
                new_string+=all_string[len(all_string)-index+3]
            else:
                new_string+=all_string[index+3]
        else:
            new_string+=x
    return new_string

def main():
    print(caesar_encrypt('attack at dawn'))
    print(caesar_encrypt('dinner is on me'))

if __name__=='__main__':
    main()

设计“跳一跳”游戏的计分函数，“跳一跳”游戏中黑色小人从一个方块跳到另一个方块上会获得1分，如果跳到方块的中心点上回获得2分，连续跳到中心点会一次获得2分、4分……该函数传入一个列表，列表中用布尔值True和False表示是否跳到方块的中心的，函数返回最后获得的分数。

def cale_score(jump_list):
    """
    ?param jump_list:给定一个列表
    >return:返回最后获得的分数
    """
    total=0
    for index,x in enumerate(jump_list):
        if x:
            total+=2
            for y in range(index-1,-1,-1):
                if jump_list[y]:
                    total+=2
                else:
                    break
        else:
            total+=1
    return total
def main():
    list1=[True,False,True,False,True]
    list2=[True,True,False,True,False,True]
    list3=[False,True,True,False,False,True,True]
    print(cale_score(list1))
    print(cale_score(list2))
    print(cale_score(list3))

if __name__=='__main__':
    main()

统计一个字符串中出现频率最高的字符及其出现的次数

def find_most_freq(string):
    """
    >param string:输入一个字符串
    >return:返回字符串中出啊洗脑频率最高的字符及其出现次数
    """

    my_dict={}
    for x in string:
        if x not in my_dict:
            my_dict[x]=1
        else:
            my_dict[x]+=1
    max_num=0
    for y in my_dict:
        if my_dict[y]>max_num:
            max_num=my_dict[y]
    max_list=[]
    for z in my_dict:
        if my_dict[z]==max_num:
            max_list+=z
    return max_list,max_num

def main():
    print(find_most_freq('aabbccddaaacc'))
    print(find_most_freq('hello world'))
    print(find_most_freq('a1bab2bcc3d4aa'))

if __name__=='__main__':
    main()

传入连个代表日期的字符串，计算连个日期相差多少天。

def is_leap_year(year):
    """
    >param year:给定一个年份
    >retrun:闰年返回true,否则返回False
    """
    return(year%400==0 or year % 100 != 0) and year % 4 == 0

def my_data(data):
    """
    >param year:给一个日期的字符串
    >retrun:返回一个整型的年月日的元组
    """    
    data_year=data[:data.find('-')]
    data_month=data[data.find('-')+1:data.find('-')]
    data_day=data[data.rfind('-')+1:]
    return int(data_year),int(data_month),int(data_day)

def days_month(year):
    """
    >param year:给定一个年份
    >retrun:返回一个包含所有月份天数的列表
    """
    year_days_month=[
        [31,28,31,30,31,30,31,31,30,31,30,31],
        [31,29,31,30,31,30,31,31,30,31,30,31]
    ][is_leap_year(year)]
    days_sum=0
    return year_days_month

def diff_days(data1,data2):
     """
    >param data1:一个日期的字符串
    >param data2:另一个日期的字符串
    >retrun:返回两个日期中间间隔了多少天
    """

    if my_data(data1)[0] == my_data(data2)[0]:
        years_day = days_month(my_data(data1)[0])
        total1=0
        for index in range(my_data(data1)[1]-1):
            total1 += years_day[index]
        days_data1 = total1+my_data(data1)[2]
        total2=0
        for index2 in range(my_data(data2)[1]-1):
            total2 += years_day[index]
        days_data2 = total2+my_data(data2)[2]
    else:
        (data1,data2) == (data1,data2) if my_data(data1)[0] > my_data(data2)[0] else (data2,data1)
        data1_years_day = days_month(my_data(data1)[0]
        total1 = 0
        for index in range(my_data(data1)[1]-1):
            total1 +=data1_years_day[index]
        days_data1 = total1 + my_data(data1)[2]
        data2_years_day = days_month(my_data(data2)[0])
        total2 = 0
        for index2 in range(my_data(data2)[1]-1):
            total2 += data2_years_day[index2]
        days_data2 = total2 + my_data(data2)[2]
        years_sum = 0
        for num in data2_years_day:
            years_sum += num
        m_years_sum = 0
        for year in range(my_data(data2)[0]+1,my_data(data1)[0]):
            year_days = days_month(year)
            for day in year_days:
                m_years_sum += day
        return years_sum-days_data2+days_data1+m_years_sum

def main():
    print(diff_days('2021-5-2','2017-9-1'))

if __name__=='__main__':
    main()

变量的作用域有哪些

在python中，一个变量的作用域总是由在代码中北赋值的地方所决定。python会按照如下顺序搜索变量：
本地作用域（local）--》 当前作用域被嵌入的本地作用域（enclosing locals) --》 全局/模块（Global）--》内置作用域（built-in

获取1-100中被6整除的偶数？

alist = []
for i in range(1,100):
    if i % 6 ==0；
        alist.append(i)
print(alist)

什么是缺省参数？

缺省参数指在调用函数的时候没有传入参数的情况下，调用默认的参数，在调用函数的同时赋值时，所传入的参数会代替默认参数

递归函数停止的条件是什么？

递归的终止条件一般定义在递归函数内部，在递归调用前要做一个条件判断，根据判断的结果选择是继续调用自身，还是return；返回种植递归。终止的条件包括：
判断递归的次数是否达到某一个限定值
判断运算的结果是否达到某个范围等，根据设计的目的来选择

回调函数是如何通信的

回调函数是把函数的指针（地址）作为参数传递给另一个函数，将整个函数当作一个对象，赋值给调用的函数

实现将1-N进行分组，每组三个数

print([[x for x in range(1,10)][i:i+3] for i in range(0,10,3)])

模块

内置模块：例如os,random，time和sys模块
第三方模块：如pygame，需要安装
自定义模块：自己写的模块
导入模块的方式： import 模块名 或者 from 模块名 import 函数名/*
内置函数中os模块是负责程序与操作系统的交互，提供了访问操作系统底层的接口，而sys模块是负责程序与python解释器的交互，提供了一系列的函数和变量，用于操纵python时运行的环境

列出当前目录下的所有的文件和目录名

import os
for i in os.listdir('.'):
    print(d)

执行shell脚本

import subprocess
result = subprocess.getoutput('dir')
print(result)

输出某个路径下的所有文件和文件夹的路径

def print_dir():
    filepath = input("请输入一个路径：")
    if filepath == "":
        print("请输入正确的路径：")
    else:
        for i in os.listdir(fiilepath):
            print(os.path.join(filepath))
print(print_dir())

随机生成100个数，然后写入到文件中

• 打开一个新文件
• 随机生成一个（整数或小数），并将该数写入文件中
• 循环第2 步，直到完成100个随机数的生成

import random
fp = open("C:\\a.txt","w")
for i in range(1,101):
    n = random.randint(1,1000)
    fp.write(str(i)+ " " + str(n) + "\n")
fp.close()

有一个使用utf8编码的文件a.txt，文件路径是C盘目录，请写一段程序逐行读取这个文本文件，并在屏幕（GBK编码）上打印出来

#coding=utf-8
import  chardet #查看字符串的编码方式模块

fp = open("C:\\me.txt")
lines = fp.readlines()
fp.close()
for line in lines:
    print line.decode("utf-8").encode('gbk',"ignore")

删除文件和用Linux命令删除文件方法分别是什么？

在Linux中可以使用rm命令，python可以使用os.remove（文件名）

import os
file = r'C:\\test.txt'
if os.path.exists(file):
    os.remove(file)
    print('delete success')
else:
    print('no such file:%s'%file)

获取当前路径

可以使用函数getcwd()，从模块os中将其导入

import os 
os.getcwd()  #查看当前路径
type(os.getcwd)
os.chdir("D:\\")  #修改当前路径
os.getcwd()

dir函数的作用

**内置函数dir可以找到模块内定义的所有的名称，以一个字符串列表的形式返回

with方法打开文件做了什么？

打开文件在进行读写的时候可能会出现一些异常情况，如果按照常规的fopen写法，那么需要try、except和finally来做异常判断，并且我呢见最终不管遇到什么情况，都要执行finally f.close()关闭文件，with方法默认实现了finally中f.close

简述read、readline、readlines的区别

read读取整个文件；readline读取下一行数据，使用生成器方法；readlines读取整个文件到一个迭代器中以供遍历使用，比较方便

pickle模块的作用

将对象写入文件或者数据库中，称之为数据的持久化保存。序列化是将对象的状态信息转化为可以存储或传输的形式的过程

• 序列化后存入文件
  pickle.dump(对象,文件对象)
• 从文件中反序列化对象
  pickle.load(文件对象)
  使用pickle模块需要注意以下几点
• 只能在python中使用，支持python的基本数据类型
• 可以处理复杂的序列化语法（例如自定义的类的方法、游戏的存档等）
• 序列化的时候，只是序列化了整个序列对象，而不是内存地址
  pickle.dumps()方法可以把任意对象序列化成一个bytes。所以首先需要创建一个对象即u=User(),然后再把这个对象序列化

u = User()
bytes = pickle.dumps(u)
#反序列化
object1 = pickle.loads(bytes)