python的小技巧系列

1、变量相关

变量交换

• 常规的写法比较麻烦：

像JAVA，C，PHP 等需要用临时变量

temp = a
a = b
b = temp

• python中较为简洁的方法

def swap_var(a, b):
    a, b = b, a
    return a, b

三元运算符

• 常规写法

def test_judge1(self):
    """
    常规判断 成绩是否及格
    """
    num = int(input("请输入一个数字："))
    if num >= 60:
        print("及格")
    else:
        print("不及格")

• 三元运算符

格式：“if 后的结果” if num >= 60 else “else的结果”

def test_judge2(self):
   """
   使用三元运算符判断  成绩是否及格
   @return:
   """
   num = int(input("请输入一个数字："))
   # 这个三元运算符和 JAVA，C不同，它if后的结果是写在最前面的
   res = "及格" if num >= 60 else "不及格"
   print(res)

一个数值的范围比较

• 常规的写法

def test_judge5(self):
    """
    判断一个值得的范围大小
    @return:
    """
    num = int(input("请输入一个数字："))
    if num >= 0 and num <= 100:
        print("数字在0-100之间")
    else:
        print("数字不在0-100之间")

• 简洁的写法

def test_judge6(self):
    """
    判断一个值得的范围大小
    @return:
    """
    num = int(input("请输入一个数字："))
    # 使用更简洁的写法
    if 0 <= num <= 100:
        print("数字在0-100之间")
    else:
        print("数字不在0-100之间")

有的场景下使用 try…exception 代替if…else

在判断字典的某一个 key 是否为空，可以用 try…exception来实现

def test_judge3(self):
    dict_data = {
        "user_base": {
            "uid": 1,
            "uname": "allen",
            "email": "hjc_042043@sina.cn"
        },
        "user_info": {
            "age": 18,
            "sex": "男"
        }
    }
    try:
        score = dict_data["user_base"]["score"]
    except KeyError:
        score = 0
    print(score)

list 在判断下标是否存在时也可以用这个方法

def test_judge4(self):
    """
    判断列表中是否有某一个索引值
    @return:
    """
    list_data = [78, 82, 93, 84, 65]
    try:
        score = list_data[6]
    except IndexError:
        score = 0
    print("学生成绩：", score)

2、字符串相关

字符串函数有很多，因篇幅优先列举3个，具体参考这个连接：https://baijiahao.baidu.com/s?id=1769926940734111824&wfr=spider&for=pc

格式化连接

• 常规的字符串连接

uid = 123
uname = 'allen'
age = 18
string = 'uid=' + str(uid) + '&uname=' + uname + '&age=' + str(age)
print(string)

• 使用字符串对象的format格式化连接

string = 'uid={}&uname={}&age={}'.format(uid, uname, age)
print("字符串对象的format方法：", string)

• 格式化方式f-string(python3.6之后)：

string = f'uid={uid}&uname={uname}&age={age}'
print("f-string：", string)

打印结果：

字符串的分割

字符串分割，默认以空白符分割，除了空格还有其他符号，比如：\t,\n,\r
也可以指定分隔符，比如：,或|，#等其他字符

def test_split(self):
    uname = "Tom green yellow"
    new_list = uname.split()
    print(new_list)

    num_str = "1,2,3,4,5,6,7,8,9,10"
    new_list = num_str.split(",")
    print(new_list)

    num_str = "1|2|3|4|5|6|7|8|9|10"
    new_list = num_str.split("|")
    print(new_list)
    pass

字符串的连接

def test_join(self):
    """
    字符串连接，默认以空白符连接，除了空格还有其他符号，比如：\t,\n,\r
    @return: 
    """
    
    list = ["Tom", "green", "yellow"]
    new_str = "".join(list)
    print(new_str)

    list = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]
    new_str = ",".join(list)
    print(new_str)

    list = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]
    new_str = "|".join(list)
    print(new_str)
    pass

3、生成器

• yield即生成器，相比return的优势是 循环体内，程序在执行到yield时，程序会暂停，并把值出栈；
  这样子就不会占用内存，下次循环进来时再接着上一次的yield的位置继续往下执行，而return的方式是先把数据都存放在栈中，一次性全部返回
• yield可以处理比较耗时，占用内存的操作，比如网络请求，文件读取等，类似异步处理，比如一边下载文件，一边把文件内容显示出来
  下面列举两个简单的例子

• 例子1：

计算100以内的平方数

import unittest

class YieldTestCase(unittest.TestCase):
    """
    todo: 计算100以内的平方数
    @return:
    """

    def test_return_square(self):
        lst = return_square()
        print(lst)
        pass

    def test_yield_square(self):
        gen = yield_square()
        for e in gen:
            print(e)
        pass

    pass


def return_square():
    """
    todo 使用return用于生成100以内的平方数
    @return:
    """
    lst = []
    for i in range(100):
        lst.append(i ** 2)
    return lst


def yield_square():
    """
    todo 使用yield实现一个生成器，用于生成100以内的平方数
    """
    for i in range(100):
        yield i ** 2

• 例子2：

测试下内存的使用情况，数值是100W

def test_yield_memory(self):
   # 先用列表推导式生成一个1000000的列表，再求和
   list1 = [x for x in range(1000000)]
   sum1 = sum(list1)
   print("推导式求和：", sum1)
   print("内存使用：", sys.getsizeof(list1), "字节")

   # 用生成器生成一个1000000的列表，再求和
   list2 = (x for x in range(1000000))
   sum2 = sum(list2)
   print("生成器求和：", sum2)
   print("内存使用：", sys.getsizeof(list2), "字节")
   pass

通过测试比较，效果一目了然，面对大数据，吃内存，耗时大的，使用生成器较好

4、列表相关

取最后一个元素

    def test9(self):
        lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        # 取最后一个元素
        print(lst[-1])

判断列表是否为空

def test10(self):
    """
    判断list是否为空
    @return:
    """
    lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    # 不好的写法：
    if len(lst) > 0:
        print('列表不为空')

    # 好的写法
    if lst:
        print('列表不为空')
    pass

列表合并

def test13(self):
    list1 = [1, "hjc", "email", 3.14, True]
    list2 = [2, "username"]
    print("将list+list2两个列表合并:", list1 + list2)

    list3 = [1, 2, 3, 4, 5]
    list4 = [6, 7, 8, 9, 10]
    print("将list3+list4两个列表合并:", [*list3, *list4])
    pass

去除列表中的重复值

def test12(self):
    """
    去掉列表中的重复值
    @return:
    """
    lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3]
    my_set = set(lst)
    print(list(my_set))
    pass

判断某个值是包含在序列中

def test11(self):
    """
    判断某个值是否包含在序列中，包含列表，字符串，元组,字典等
    @return:
    """
    lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    num = 5

    # 某个值是否包含在列表中，类似于 JAVA 的 a.contains(b)方法
    if num in lst:
        print('列表中包含该元素')
    else:
        print('列表中不包含该元素')

    # 某个字符子串是否包含着一个字符串中
    string = 'hello world'
    if 'hello' in string:
        print('字符串中包含该子串')
    else:
        print('字符串中不包含该子串')

    # 字典的键是否包含在字典中
    dic = {'name': 'allen', 'age': 20}
    if 'name' in dic:
        print('字典中包含该键')
    else:
        print('字典中不包含该键')

    pass

列表推导式

• 常规for循环

def test1(self):
   """
   使用常规的for循环遍历列表，将列表中的元素转换为大写
   @return: 
   """
   new_list = []
   for fruit in self.fruites:
       new_list.append(fruit.upper())
   print(new_list)
   pass

• 列表推导式：

这个推导式中的含义是：
①先看for循环，把元素遍历出来，
②再看 fruit.upper(),把循环体中元素转换为大写，
③最后把结果赋值给new_list

def test2(self):
   """
   todo：使用列表推导式将列表中的元素转换为大写
   @return:
   """
   new_list = [fruit.upper() for fruit in self.fruites]
   print(new_list)
   pass

带条件的列表推导式

• 常规

列表遍历，并且将以 a 开头的元素转换为大写

def test3(self):
   new_list = []
   for fruit in self.fruites:
       if fruit.startswith('a'):
           new_list.append(fruit.upper())
   print(new_list)
   pass

• 推导式简写

def test4(self):
    new_list = [fruit.upper() for fruit in self.fruites if fruit.startswith('a')]
    print(new_list)
    pass

5、字典相关

俩字典合并

格式：新的字典 = {**字典1,**字典2}

def test_dict_merge(self):
   """
   合并两个字典
   :return:
   """
   dict1 = {"a": 1, "b": 2, "c": 3}
   dict2 = {"d": 4, "e": 5, "f": 6}

   # 这里两个字典的**表示解包，将两个字典的键值对合并成一个新的字典
   new_dict = {**dict1, **dict2}
   print(new_dict)

字典反转

使用map 函数来对字典序列，回调反转排序函数

def test_everse(self):
   """
   字典反转

   @return: 
   """
   dict1 = {
       'one': 1,
       'tow': 2,
       'three': 3
   }
   new_dict = dict(map(reversed, dict1.items()))
   print(new_dict)

对字典列表中的元素进行排序

def test_sort_item(self):
    """
    根据字典列表中的字典元素年龄进行倒序排列
    @return:
    """
    dict_list = [
        {'name': 'allen', 'age': 18},
        {'name': 'john', 'age': 20},
        {'name': 'tom', 'age': 15}
    ]
    new_dict_list = sorted(dict_list, key=lambda x: x['age'], reverse=True)
    print(new_dict_list)

将两个列表的值组成字典

def test_lists_to_dict(self):
    """
    将两个列表合并到一个字典中,一个列表的值作为 key,另一个列表的值作为 value
    @return:
    """
    keys = ['a', 'b', 'c']
    values = [1, 2, 3]
    new_dict = zip(keys, values)
    print(dict(new_dict))
    pass

字典推导式

字典推导式和列表推导式类似，只不过中括号改成大括号而已，区别就是字典推导式返回的类型是字典

• 格式：

格式1：{key:value for value in iterable(可迭代对象)}

格式2：{key:value for value in iterable(可迭代对象) if 条件}

• 代码示例1：

不带条件

lst = ['hello', 'python', 'java']
# 还原字典推导式的实现
# new_dict = {}
# for x in lst:
#     new_dict[x] = len(x)
# print(new_dict)

dic = {x: len(x) for x in lst}
print(dic)

• 代码示例2：

带条件

"""
利用推导式计算一组股票价格大于100元的值
:return:
"""
d = {
    "601800": 10.74,
    "300776": 62.98,
    "300576": 44.10,
    "002594": 260.5,
    "300750": 223.47,
    "600519": 1711.05,
}
# 还原字典推导式
# new_dict = {}
# for key,val in d.items():
#     if val > 100:
#       new_dict[key] = val
    
new_dict = {key: val for key, val in d.items() if val > 100}
print("new_dict=", new_dict)

6、循环

带索引值的循环

使用enumerate 函数，来获取索引和值

def test5(self):
    for i, value in enumerate(self.fruites):
        print(i, value)

反向遍历

使用reversed 函数实现反向遍历

def test6(self):
	"""
	反向遍历
	@return: 
	"""
	for i,value in enumerate(reversed(self.fruites)):
	    print(i,value)

反向遍历2,使用切片步长方式，[::-1]来实现，-1表示步长从从倒序开始取

def test7(self):
    """
    
    @return:
    """
    for i, value in enumerate(self.fruites[::-1]):
        print(i, value)

正向遍历

def test8(self):
    """
    顺序遍历
    @return: 
    """
    for i, value in enumerate(sorted(self.fruites)):
        print(i, value)

7、文件相关

读取文件方式一：

按常规的方式来读取文件，以默认只读方式打开文件—>读取内容—>关闭文件
因为不管异常是否处理,文件都要关闭操作

def test_read(self):
    global file
    try:
        file = open(get_sources_dir() + "2.txt")
        text = file.read()  # 读取文件内容
        print(text)
    except Exception as e:
        print(e)
    finally:
        file.close()
    pass

读取文件方式二：

方式一，使用手动来关闭文件资源，不是很方便，不关闭又会一直占用文件资源
所以使用with…as上下文语句来处理更佳，它会自动帮我们关闭文件，并且代码简洁

def test_read(self):
    """
    读取文件的内容
    :return:
    """
    with open(get_sources_dir() + "2.txt", "r", encoding="utf-8") as f:
        content = f.read()
        print(content)
    pass

删除文件时注意

• 删除文件

删除文件时，一定要判断文件是否存在，万一文件路径是个空的，不判断就会把目录删除掉，这样子后果严重

def test_rmfile(self):
    """
    如果文件存在就删除文件
    :return:
    """
    rm_file = get_sources_dir() + "write_big.txt"
    try:
        if os.path.isfile(rm_file):
            res = os.remove(rm_file)
            print("res=", res)
        else:
            print("文件不存在！")
    except OSError as e:
        print(e)
        pass

• 删除目录

一般删除目录较少用，不会直接去删除，其判断方法和删除文件一样

def test_rmdir(self):
    rm_dir = get_sources_dir() + "test1"
    try:
        if os.path.isdir(rm_dir):
            # 如果是合法目录
            res = os.rmdir(rm_dir)
            print("res=", res)
        else:
            print("目录不存在！")
    except OSError as e:
        print(e)
        pass