编写python函数常用技巧代码（一）

末蓝、 2023-09-29 10:08 124阅读 0赞

**目录**

系列文章目录

一. 字符串操作

二. 格式化输出

三. dict常用操作

四. list操作

五. 迭代器

六. 元组

七. 变量

八. 偏导函数

九. 装饰器

十. 模块导入

十一. 程序入口

--------------------

## 系列文章目录 ##

[第一章：python常见报错及解决方案][python]

[第二章：编写python函数常用技巧代码（一）][python 1]

[第三章：编写python函数常用技巧代码（二）][python 2]

--------------------

## 一. **字符串操作** ##

**1）大小写转换**

*  **转换成大写：**
    
        my_str = "j2hdksil mk"
        res = my_str.upper()
        print(res)
 *  **转换成小写：** 
    
        my_str = "J2HDKSIL MK"
        res = my_str.lower()
        print(res)
 *  **首字母大写 :**
    
        my_str = "j2hdksil mk"
        res = my_str.capitalize()
        print(res)
 *  **将每个单词的首字母大写 ：**
    
        my_str = "j2hdksil mk"
        res = my_str.title()
        print(res)
 *  **大小写互相转换：**
    
        my_str = "I love I"
        res = my_str.swapcase()
        print(res)

**2）字符串的切分**

# 2对应参数位置 表示的是切分几次
    my_str = "j2hdksil mk"
    res = my_str.split(" ",2)
    print(res)

**3）去掉左右侧指定字符**

*  **去掉左侧指定字符**
    
        my_str = "I love I"
        l_res = my_str.lstrip("I")
        print(res)
 *  **去掉右侧指定字符**
    
        my_str = "I love I"
        r_res = my_str.rstrip("I")
        print(res)
 *  **同时去掉两侧的字符**
    
        my_str = "I love I"
        res= my_str.strip('I')
        print(res)

**4）字符串连接**

my_str = "I love I"
    res = "+".join(my_str)
    print(res)

**5）对齐**

*  **左对齐：**
    
        my_str = "we"
        res = my_str.ljust(4, '‐')
        print(res)
 *  **右对齐：**
    
        my_str = "we"
        res = my_str.rjust(4, '+')
        print(res)
 *  **zfill 将字符串右对齐 然后位数不够用0补：**
    
        # 注意当指定位数小于字符串长度 使用的是字符串长度本身
        my_str = "we"
        res = my_str.zfill(3)
        print(res)

**6）居中**

my_str = "w"
    res = my_str.center(5, "i")
    print(res)

**7）****字符串的替换**

> **replace('你要替换的字符串’， ‘用什么替换’， '替换多少个')**

my_str = "I love I"
    res = my_str.replace("I",'8')
    print(res)
    
    res1 = my_str.replace('I', '8', 1)
    print(res1)
    # ‘I’ 是我要替换的 用‘8’来替换， 1说的是替换的个数

**8）****切分**

> **按照第一个匹配的字符去切分 保留指定切分的切分字符，****变成元组,元组第一项是切分字****符左侧的内容 第二项是你指定切分字符 第三项是切分字符右侧的内容**

my_str = "I love I"
    res = my_str.partition("o")
    print(res)

**9）****统计字符出现的个数**

> **count(统计的字符,起始值，结束值)**

my_str = "I love I"
    res = my_str.count("I", 0, 7)
    print(res)

--------------------

## **二. 格式化输出** ##

*   **%后的变量是依次赋值给你的占位符** 
    
        age = 18
        money = 100000000
        print("我的年纪是%d" % age)
        # 多个值的情况 “字符串%d呵呵呵%d” % (age, money)
        print("我的年纪是%d,我的存款%d津巴布韦币" % (money, money))
    
    >  **%后的变量是依次赋值给你的占位符** 
    > 
    >  *  %d 整数 
    >  *  2 %f float类型 默认输出小数部分是6位 如果想保留自己制定长度 那么使用%.位数 
    >  *  3 %s 字符串
 *  **使用format** 
    
        name = "张三"
        age = 30 
        weight = 80.2 
        print("我叫{}, 我今年{}岁， 我体重是{}kg".format(name, age, weight))

--------------------

## 三. **dict常用操作** ##

**1）字典生成式** **：**

a = [(1,2),("name","kobe")]
    res = {key:value for key,value in a}
    print(res)

**2）clear()：**

> **清空字典**

my_dict = {"name":"lucy","age":20}
    print(my_dict.clear())

**3）frokeys()：**

> **生成一个新的字典 第一个参数 是指定你的key序列，第二个参数是字典对应的value**

my_dict = {"name":"lucy","age":20}
    res = my_dict.fromkeys([1,2,3], "j")
    print(res)

**4）****items()：**

> **将字典转成列表嵌套元组的形式**

my_dict = {"name":"lucy","age":20}
    res = res = my_dict.items()
    print(res)

**5）****key()：**

> **获取字典所有的键**

my_dict = {"name":"lucy","age":20}
    res = res = my_dict.keys()
    print(res)

**6）****values()：**

> **获取字典所有的值**

my_dict = {"name":"lucy","age":20}
    res = res = my_dict.values()
    print(res)

**7）****pop(key)：**

> **弹出一个key对应的value值, 原来字典将会删除掉对应的键值****对**

my_dict = {"name":"lucy","age":20}
    res = res = my_dict.pop("name")
    print(res)
    print(my_dict)

**8）****popitem()：**

> **弹出字典的一项 然后原来的字典 将会移除掉对应键值对**

my_dict = {"name":"lucy","age":20}
    res = res = my_dict.popitem()
    print(res)
    print(my_dict)

**9）****setdefault(key, value)：**

> **在原来字典的基础上 添加一个键值对 如果key 存在将不会设置成功， 如果key不存在 那么才生效, 函数操作的返回结果 如果key存在是 原来这个key对应value 否则返回的是你设置的value**

my_dict = {"name":"lucy","age":20}
    res = my_dict.setdefault("name", 'lili')
    print(res)
    print(my_dict)

**10）update(字典)：**

> **在原来字典的基础上追加新的键值对，如果key有相同的那么更新原来字典key所对应的value**

my_dict = {"name":"lucy","age":20}
    my_dict2 = {"money":10, "hobby":[1,2,34], 'name':"bob"}
    my_dict.update(my_dict2)
    print(my_dict)

**11）sorted ()：**

dict_data = {"语文":59, "数学": 79, "化学":90, "物理":30, "python": 100}
    res = sorted(dict_data.items(), key=lambda item:item[1])
    print(res)

--------------------

## **四. list操作**  ##

**1）****列表生成式：**

res = [i for i in range(0,10,2) if i %2 ==0]
    print(res)

**2）count()：**

> 计数，来统计列表元素出现的次数

list = ["abc", "abcd", "e", "as", "abc"]
    print(list.count('abc'))

**3）extend()：**

> 将另一个 list 追加到调用列表后边

list = ["abc", "abcd", "e", "as", "abc"]
    temp = [1,2,4]
    list.extend(temp)
    print(list)

**4）****index（要找的元素，找的起始值，找的末位值）：**

> 返回你要查找元素的下标（返回的是匹配到的第一个元素），如果元素不在列表里，那么他将会报一个ValueError

list = ["abc", "abcd", "e", "as", "abc"]
    print(list.index("abc",2, len(list)))

**5）****insert（要插入的位置，要插入的元素）：**

> 当给定的index较大的时候 那么追加到数组的最后

list = ["abc", "abcd", "e", "as", "abc"]
    list.insert(10002, "9")
    print(list)

**6）****pop(需要弹出的下标)：**

> 返回弹出的元素 在原来的列表删除对应的下标元素

list = ["abc", "abcd", "e", "as", "abc"]
    print(list.pop(0))
    print(list)

**7）****remove（要移除的元素）：**

> 不返回删除的元素（删除的是他匹配的第一个）
> 
> 如果要移除的元素没在列表里 那么将会报 ValueError异常

list = ["abc", "abcd", "e", "as", "abc"]
    print(list.remove("abc"))
    print(list)

**8）****reverse（）** ：

> 将列表反转、逆序，没有返回值 ，而是直接影响原字符串

list = ["abc", "abcd", "e", "as", "abc"]
    list.reverse()
    print(list)

**9）****sort（key, reverse）：**

> 排序，默认是对数组里的元素的ascll码比较 
> 
> 如果指定了key参数（排序规则），就使用新的规则， 
> 
> reverse来设置是不是降序排列，默认False是升序

# 指定排序的规则
    def str_len(my_str):
        return len(my_str)
    # 排序
    list = ["abc", "bcda", "e", "cs", "abc"]
    list.sort((key=str_len, reverse=True)
    print(list)

--------------------

## **五. 迭代器** ##

**1）****可迭代对象**

> 通俗的讲，就是 for可以直接遍历的字符串（list dict set tuple）
> 
> isinstance（object, classinfo ）：如果参数object是classinfo的实例，或者object是classinfo类的子类的一个实例， 返回True。如果object不是一个给定类型的的对象， 则返回结果总是False。
> 
> 功能：帮助我们判断变量是不是这个类名的实例

**2）迭代器**

> python 给我们提供了迭代器来优化此问题：不浪费内存，当你使用的时候 他才给你计算拿 
> 
> 出来
> 
> 声明：
> 
> 1  将列表生成式的中括号变成小括号 
> 
> 2  函数与 yield 关键字组合形成一个迭代器 
> 
> yield 与 return 区别：
> 
> return  结束函数 
> 
> 而 yield 只是停止了迭代器（函数）的调用 
> 
> 都可以返回值 
> 
> 访问：使用内置 next ( 迭代器对象 ) 函数 
> 
> 当我们的迭代器对象为空的时候 报错

## **六.** **元组** ##

>  *  当我们直接使用括号表示一个元组的时候，如果只有一个元素，为防止歧义，要在元素后加一个逗号操作；
>  *  元组不可以修改，但可以使用+或\*，可以通过下标访问；
>  *  count（元素）： 统计元素在元组里出现的次数；
>  *  index（元素）： 查找第一个匹配到的元素下标，如果不在元组，会报错。

## **七. 变量** ##

**1）****global：**

> 在函数内用于global修饰的变量是全局变量

a = 10
    def fun1():
        global a 
    a = 6
    fun1()
    print(a)

**2）nonlocal：**

> 闭包中 如果内部函数想去修改外部函数的变量， 
> 
> 那我们就需要使用 nonlocal 来修饰我们想要修改的变量。

def fun3():
        b = 10
        def inner():
            nonlocal b
            b = 5
        inner() 
        print(b)
        return inner
    fun3()

##  **八. 偏导函数**  ##

> 作用：帮我们 ’ 冻结 ‘ 函数的参数，然后得到新的函数，在调用得到的新的函数时，之需要写剩余的参数就可以

from functools import partial
    
    print_new = partial(print, end="!", sep="+")
    print_new("sjs", "jj")

##  **九. 装饰器** ##

def out(装饰器需要的参数):
        def dec_two(fun):
            def inner(*args):
                if 装饰器参数 写一些逻辑:
                    fun(*args)
                else:
                    print("权限不够")
                return inner
        return dec_two

## **十. 模块导入** ##

> from xxx import 成员 as 别名
> 
> 当 from  xxx  import  \*  的时候，如果 xxx里的一些成员不想被外部使用，
> 
> 那么可以使用\_\_all\_\_  =  \[ ' 放你想暴露的成员 ' \]

## 十一. **程序入口**  ##

> 表示我们程序运行的开始位置
> 
> \_\_name\_\_  在主文件，打印结果是\_\_main\_\_，如： if  \_\_name\_\_  ==  "\_\_main\_\_" :
> 
> 在非主文件（模块文件），打印的时候是模块的名字

[python]: https://blog.csdn.net/weixin_53919192/article/details/123940511?spm=1001.2014.3001.5502
[python 1]: https://blog.csdn.net/weixin_53919192/article/details/124157730
[python 2]: https://blog.csdn.net/weixin_53919192/article/details/124179321