python开发过程中常用的9个tips

1 字符串转字节

将一个
<br /> 字符串<br />
转换成
<br /> 字节<br />
类型

In [1]: s = "apple"

In [2]: bytes(s,encoding='utf-8')
Out[2]: b'apple'

2 转为字符串

将
<br /> 字符类型<br />
、
<br /> 数值类型<br />
等转换为
<br /> 字符串<br />
类型

In [1]: i = 100

In [2]: str(i)
Out[2]: '100'

3 转为字典

创建数据字典

In [1]: dict()
Out[1]: {}

In [2]: dict(a='a',b='b')
Out[2]: {'a': 'a', 'b': 'b'}

In [3]: dict(zip(['a','b'],[1,2]))
Out[3]: {'a': 1, 'b': 2}

In [4]: dict([('a',1),('b',2)])
Out[4]: {'a': 1, 'b': 2}

4 转为浮点类型

将一个整数或数值型字符串转换为浮点数

In [1]: float(3)
Out[1]: 3.012

如果不能转化为浮点数，则会报
<br /> ValueError<br />
:

In [2]: float('a')
# ValueError: could not convert string to float: 'a'

5 转为集合类型

返回一个set对象，集合内不允许有重复元素：

In [159]: a = [1,4,2,3,1]

In [160]: set(a)
Out[160]: {1, 2, 3, 4}

6 打开文件

返回文件对象

In [1]: fo = open('D:/a.txt',mode='r', encoding='utf-8')

In [2]: fo.read()
Out[2]: '\ufefflife is not so long,\nI use Python to play.'

mode取值表：

7 创建属性的两种方式

（1）返回 property 属性，典型的用法：

class C:
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x

    def setx(self, value):
        self._x = value

    def delx(self):
        del self._x
    # 使用property类创建 property 属性
    x = property(getx, setx, delx, "I'm the 'x' property.")

（2）使用python装饰器，实现与上完全一样的效果代码：

class C:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

8 函数的五类参数使用例子

Python五类参数：位置参数、关键字参数、默认参数、变量位置参数和关键字参数的使用规范

def f(a,*b,c=10,**d):
    print(f'a:{a},b:{b},c:{c},d:{d}')12

默认参数
<br /> c<br />
不能位于可变关键字参数
<br /> d<br />
后.

调用f:

f(1,2,5,width=10,height=20)
	a:1,b:(2, 5),c:10,d:{'width': 10, 'height': 20}

可变位置参数
<br /> b<br />
实参后被解析为元组
<br /> (2,5)<br />
;而c取得默认值10; d被解析为字典.

再次调用f:

f(a=1,c=12)a:1,b:(),c:12,d:{}

传入a=1时，a为关键字参数，b和d不传值，c传入12而不是默认值。

注意观察参数
<br /> a<br />
, 既可以
<br /> f(1)<br />
,也可以
<br /> f(a=1)<br />
其可读性比第一种更好，建议使用f(a=1)。如果要强制使用
<br /> f(a=1)<br />
，需要在前面添加一个

星号

:

def f(*,a,*b):  
    print(f'a:{a},b:{b}')

此时f(1)调用，将会报错：
<br /> TypeError: f() takes 0 positional arguments but 1 was given<br />

只能
<br /> f(a=1)<br />
才能OK.

说明前面的
<br /> *<br />
发挥作用，它变为只能传入关键字参数，那么如何查看这个参数的类型呢？借助python的
<br /> inspect<br />
模块：

In [22]: for name,val in signature(f).parameters.items():
    ...:    print(name,val.kind)
    ...:
a KEYWORD_ONLY
b VAR_KEYWORD

可看到参数
<br /> a<br />
的类型为
<br /> KEYWORD_ONLY<br />
，也就是仅仅为关键字参数。

但是，如果f定义为：

def f(a,*b):
  print(f'a:{a},b:{b}')

查看参数类型：

In [24]: for name,val in signature(f).parameters.items():
    ...:     print(name,val.kind)
    ...:
a POSITIONAL_OR_KEYWORD
b VAR_POSITIONAL

可以看到参数
<br /> a<br />
既可以是位置参数也可是关键字参数。

9 lambda 函数的动画演示

有些读者反映，
<br /> lambda<br />
函数不太会用，问我能不能解释一下。

比如，下面求这个
<br /> lambda<br />
函数：

def max_len(*lists):
    return max(*lists, key=lambda v: len(v))

有两点疑惑：

• 参数
  <br /> v<br />
  的取值？
• <br /> lambda<br />
  函数有返回值吗？如果有，返回值是多少？

调用上面函数，求出以下三个最长的列表：

r = max_len([1, 2, 3], [4, 5, 6, 7], [8])
print(f'更长的列表是{r}')

程序完整运行过程，动画演示如下：

结论：

• 参数v的可能取值为
  <br /> *lists<br />
  ，也就是
  <br /> tuple<br />
  的一个元素。

• <br /> lambda<br />
  函数返回值，等于
  <br /> lambda v<br />
  冒号后表达式的返回值。