Python实践手册-基础操作

1.求绝对值

abs(-6)

6

2.列表真值判别

1）接受一个迭代器，如果迭代器的 所有元素 都为真，那么返回 True ，否则返回False

my_list1 = [1,2,3,4,0]
all(my_list1)

False

my_list2 = [1,2,3,4,5]
all(my_list2)

True

2）接受一个迭代器，如果迭代器里 至少有一个 元素为真，那么返回 True ，否则返回 False

any([0,0,0,8])

True

any([0,0,0,0])

False

3.ascii展示对象

调用对象的repr() 方法，获得该方法的返回值，如下例子返回值为字符串

class Student():
    def __init__(self,id,name):
        self.id = id
        self.name = name
    def __repr__(self):
        return 'id = '+self.id + ', name = '+self.name

jack = Student(id='9527',name='jack')
print(jack)

id = 9527, name = jack

ascii(jack)

'id = 9527, name = jack'

4.进制转换

1）十进制转二进制

bin(7)

'0b111'

2）十进制转八进制

oct(25)

'0o31'

3）十进制转十六进制

hex(32)

'0x20'

5.对象判空

bool([0,0,0,0,0]) # 对象有值，非空，返回True

True

bool([]) # 对象为空，返回False

False

6.数据格式转换

1）字符串转字节

s = "jack"
bytes(s,encoding='utf-8')

b'jack'

2）字符类型/数值类型等转字符串类型

i = 9527
s_i = str(i)
print("i:",i)
print("type of i:",type(i))
print("s_i:",s_i)
print("type of s_i:",type(s_i))

i: 9527
type of i: <class 'int'>
s_i: 9527
type of s_i: <class 'str'>

3）十进制数转ASCII码

chr(74)

'J'

4）ASCII码转十进制数

ord('J')

74

7.判断是否可调用

判断对象是否可被调用，能被调用的对象就是一个 callable 对象

callable(str)

True

callable(int)

True

jack
id = 9527,name = jack
callable(jack)

  File "<ipython-input-34-1b60e00c632b>", line 2
    id = 9527,name = jack
        ^
SyntaxError: can't assign to literal

class Student():
    def __init__(self,id,name):
        self.id = id
        self.name = name
    def __repr__(self):
        return 'id = '+self.id+', name = '+self.name
    def __call__(self):
        print('I can be called!')
        print(f'my name is {self.name}')
    
t = Student('9527','jack')
t()

I can be called!
my name is jack

8.静态方法

classmethod 装饰器对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

class Student():
    def __init__(self,id,name):
        self.id = id
        self.name = name
    def __repr__(self):
        return 'id = '+self.id+', name = '+self.name
    @classmethod
    def f(cls):
        print(cls)

9.执行字符串表示的代码

将字符串编译成python能识别或可执行的代码，也可以将文字读成字符串再编译。

s = "print('Hell World!')"
r = compile(s,"<string>","exec")
r

<code object <module> at 0x000002A224792270, file "<string>", line 1>

exec(r)

Hell World!

10.创建复数

complex(1,4)

(1+4j)

11.动态删除类对象属性

hasattr(jack,'id')

True

delattr(jack,'id')
hasattr(jack,'id')

False

12.创建字典

dict()

{}

dict(id='id',name='name')

{'id': 'id', 'name': 'name'}

dict(zip(['id','name'],['9527','jack']))

{'id': '9527', 'name': 'jack'}

13.查看对象所有方法

不带参数时返回 当前范围 内的变量、方法和定义的类型列表；带参数时返回 参数的属性，方法列表。

dir(jack)

['__class__',
 '__delattr__',
 '__dict__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__le__',
 '__lt__',
 '__module__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 '__weakref__',
 'name']

14.取商和余数

divmod(25,3)

(8, 1)

15.枚举对象

返回一个可以枚举的对象，该对象的next()方法将返回一个元组。

s = ['a','b','c']
for i,v in enumerate(s,1):
    print(i,v)

1 a
2 b
3 c

16.计算表达式

将字符串str 当成有效的表达式来求值并返回计算结果取出字符串中内容

s = "9+5+2+7"
eval(s)

23

17.查看变量所占字节数

import sys
my_dict = {'a':1,'b':2.0}
sys.getsizeof(my_dict)

240

18.过滤器

在函数中设定过滤条件，迭代元素，保留返回值为 True 的元素：

fil = filter(lambda x:x>10,[11,9,5,2,7,9527])
list(fil)

[11, 9527]

19.字符串格式化

格式化输出字符串，format(value, format_spec)实质上是调用了value的format(format_spec)方法。

print("I am {},age {}".format("jack",18))

I am jack,age 18

20.创建一个不可修改的冻结集合

f_list = frozenset([1,1,3,2,3])
f_dict = frozenset({1,2,3})
f_list.add(10)

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

AttributeError                            Traceback (most recent call last)

<ipython-input-72-0d113b602624> in <module>
      1 f_list = frozenset([1,1,3,2,3])
      2 f_dict = frozenset({1,2,3})
----> 3 f_list.add(10)


AttributeError: 'frozenset' object has no attribute 'add'

21.动态获取对象属性

class Student():
    def __init__(self,id,name):
        self.id = id
        self.name = name
    def __repr__(self):
        return 'id = '+self.id+',name = '+self.name
jack = Student(id='9527',name='jack')
hasattr(jack,'name')

True

getattr(jack,'name')

'jack'

hasattr(jack,'address')

False

22.返回对象的哈希值

返回对象的哈希值，值得注意的是自定义的实例都是可哈希的， list , dict ,set 等可变对象都是不可哈希的(unhashable)

hash(jack)

-9223371855887599328

hash([520,9527])

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

TypeError                                 Traceback (most recent call last)

<ipython-input-83-e567d6d061d0> in <module>
----> 1 hash([520,9527])


TypeError: unhashable type: 'list'

23.查看帮助文档

help(jack)

Help on Student in module __main__ object:

class Student(builtins.object)
 |  Student(id, name)
 |  
 |  Methods defined here:
 |  
 |  __init__(self, id, name)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)

24.查看对象的内存地址

id(jack)

2895474823688

25.获取用户输入内容

input()

I am jack,my code is 9527 !





'I am jack,my code is 9527 !'

26.isinstance

判断object是否为类classinfo的实例，是返回true

class Student():
    def __init__(self,id,name):
        self.id = id
        self.name = name
    def __repr__(self):
        return 'id = '+self.id+',name = '+self.name

jack = Student(id='9527',name='jack')
isinstance(jack,Student)

True

27.父子关系鉴定

class undergraduate(Student):
    def studyClass(self):
        pass
    def attenActivity(self):
        pass

issubclass(undergraduate,Student)

True

issubclass(object,Student)

False

issubclass(Student,object)

True

28.创建迭代器类型

使用 iter(obj, sentinel) , 返回一个可迭代对象, sentinel可省略(一旦迭代到此元素，立即终止)

lst = [1,3,5]
for i in iter(lst):
    print(i)

1
3
5

class TestIter(object):
    def __init__(self):
        self.l = [1,2,3,4,5,2,4]
        self.i = iter(self.l)
    def __call__(self): #定义了__call__方法的类的实例是可调用的
        item = next(self.i)
        print("__call__ is called,fowhich would return",item)
        return item
    def __iter__(self): #支持迭代协议
        print("__iter__ is called!!")
        return iter(self.l)
    
t = TestIter()  # 因为实现了__call__，所以t实例能被调用
t()

__call__ is called,fowhich would return 1





1

for e in TestIter():  # 因为实现了__iter__方法，所以t能被迭代
    print(e)

__iter__ is called!!
1
2
3
4
5
2
4

29.打开文件

fo = open("../data/a.txt",mode='r',encoding='utf-8')
fo.read()

'Hello!My name is Jack\nMy code is 9527!'

30.创建属性的两种方式

方法一：返回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.")

方法二（推荐）：使用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

31.四舍五入

四舍五入， ndigits 代表小数点后保留几位：

round(3.1415926535,3)

3.142

32.转为集合类型

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

a = [9,9,5,5,2,2,7,7]
set(a)

{2, 5, 7, 9}

33.转为切片对象

返回一个表示由 range(start, stop, step) 所指定索引集的 slice对象，它让代码可读性、可维护性变好。

a = [1,4,2,3,1]
my_slice_meaning = slice(0,5,2)
a[my_slice_meaning]

[1, 2, 1]

a[0:5:2]

[1, 2, 1]

34.排序函数

a = [1,3,9,4,7,2]
sorted(a,reverse=True)

[9, 7, 4, 3, 2, 1]

b = [{'name':'jack','age':30,'gender':'male'},
    {'name':'chenyao','age':20,'gender':'female'}]
sorted(b,key=lambda x:x['age'])

[{'name': 'chenyao', 'age': 20, 'gender': 'female'},
 {'name': 'jack', 'age': 30, 'gender': 'male'}]

35.转元组

tuple() 将对象转为一个不可变的序列类型

my_list = [9,5,2,7]
my_tuple = tuple(my_list)
my_tuple

(9, 5, 2, 7)

36.查看对象类型

传入一个参数时，返回 object 的类型：

class Student():
    def __init__(self,id,name):
        self.id = id 
        self.name = name
    def __repr__(self):
        return 'id = '+self.id+',name = '+self.name
    
jack = Student(id='9527',name='jack')
type(jack)

__main__.Student

37.聚合迭代器

创建一个聚合了来自每个可迭代对象中的元素的迭代器：

x = [3,2,1]
y = [4,5,6]
list(zip(y,x))

[(4, 3), (5, 2), (6, 1)]

a = range(1,6)
b = list('abcde')
b

['a', 'b', 'c', 'd', 'e']

[str(y) + str(x) for x,y in zip(a,b)]

['a1', 'b2', 'c3', 'd4', 'e5']

38.global

global 在函数h内，显示地告诉编译器 i 为全局变量，然后编译器会在函数外面寻找 i 的定义，执行完 i+=1 后， i 还为全局变量，值加1：

i = 0
def h():
    global i 
    i += 1
h()
print(i)

1

39.不用if,else实现计算器

from operator import *

def calculator(a,b,k):
    return {
        '+':add,
        '-':sub,
        '*':mul,
        '/':truediv,
        '**':pow
    }[k](a,b)
res_1 = calculator(1,2,'+')
print(f'res_1:{res_1}')
res_2 = calculator(3,4,'**')
print(f'res_2:{res_2}')

res_1:3
res_2:81

40.链式操作

from operator import (add,sub)

def add_or_sub(a,b,oper):
    return (add if oper == '+' else sub)(a,b)

add_or_sub(1,2,'-')

-1

41.交换两元素

def swap(a,b):
    return b,a
print(swap(1,0))

(0, 1)

42.去最求平均

def score_mean(lst):
    lst.sort()
    lst2 = lst[1:len(lst)-1]
    return round(sum(lst2)/len(lst2),1)
lst=[9.1, 9.0,8.1, 9.7, 19,8.2, 8.6,9.8]
score_mean(lst)

9.1

43.打印99乘法表

for i in range(1,10):
    for j in range(1,i+1):
        print('{}*{}={}'.format(j,i,j*i),end='\t')
    print()

1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81	

44.全展开

将如下数组[[[1,2,3],[4,5]]]完全展开成一维

方法一：flatten递归版

from collections.abc import *

def flatten(lst,out_lst=None):
    if out_lst is None:
        out_lst = []
    for i in lst:
        if isinstance(i,Iterable):
            flatten(i,out_lst)
        else:
            out_lst.append(i)
    return out_lst

print(flatten([[1,2,3],[4,5]]))
print(flatten([[1,2,3],[4,5]], [6,7]))
print(flatten([[[1,2,3],[4,5,6]]]))

[1, 2, 3, 4, 5]
[6, 7, 1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 6]

方法二：numpy flatten

import numpy
b = numpy.array([[1,2,3],[4,5]])
b.flatten()

array([list([1, 2, 3]), list([4, 5])], dtype=object)

45.列表等分

from math import ceil 

def divide(lst,size):
    if size <= 0:
        return [lst]
    if len(lst)%size !=0:
        lst.extend([0]*(size-len(lst)%size))
    return [lst[i*size:(i+1)*size] for i in range(0,ceil(len(lst)/size))]
r = divide([1,2,3,4,5,6,7,8,9,10],3)
print(r)

[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 0, 0]]

46.列表压缩

def filter_false(lst):
    return list(filter(bool,lst))

r = filter_false([None, 0, False, '', [], 'ok', [1, 2]])
print(r)

['ok', [1, 2]]

47.最长列表

def max_length(*lst):
    return max(*lst,key=lambda v:len(v))  #返回长度最大的那个列表

r1 = max_length([1,2,3],[4,5,6,7],[8])
print(f'最长的列表是{r1}')
r2 = max_length([1,2,3],[4,5,6,7],[9,5,2,7,5])
print(f'最长的列表是{r2}')

最长的列表是[4, 5, 6, 7]
最长的列表是[9, 5, 2, 7, 5]

48.求出现次数最多的数

def top1(lst):
    return max(lst,default='列表为空',key=lambda v:lst.count(v))
lst = [1,3,3,2,1,1,2]
r = top1(lst)
print(f'{lst}中出现次数最多的元素为：{r}')

[1, 3, 3, 2, 1, 1, 2]中出现次数最多的元素为：1

49.多表之最

def max_lists(*lst):
    return max(max(*lst,key=lambda v:max(v)))
r = max_lists([1, 2, 3], [6, 7, 8], [4, 5],[9,5,2,7])
print(r)

9

50.列表查重

def has_duplicates(lst):
    return len(lst) == len(set(lst))

x = [1, 1, 2, 2, 3, 2, 3, 4, 5, 6]
y = [1, 2, 3, 4, 5]
print(f'{x}列表无重复元素：{has_duplicates(x)}')
print(f'{y}列表无重复元素：{has_duplicates(y)}') 

[1, 1, 2, 2, 3, 2, 3, 4, 5, 6]列表无重复元素：False
[1, 2, 3, 4, 5]列表无重复元素：True

51.列表反转

def reverse(lst):
    return lst[::-1]
r = reverse([1, -2, 3, 4, 1, 2])
print(r) 

[2, 1, 4, 3, -2, 1]

52.浮点数等差数列

def rang(start,stop,n):
    start,stop,n = float('%.2f' % start) , float('%.2f' % stop),int('%.d' % n)
    step = (stop-start)/n
    lst = [start]
    while n > 0:
        start,n = start + step,n-1
        lst.append(round((start),2))
    return lst

rang(1,8,10)

[1.0, 1.7, 2.4, 3.1, 3.8, 4.5, 5.2, 5.9, 6.6, 7.3, 8.0]

53.按条件分组

def bif_by(lst,f):
    return [[x for x in lst if f(x)],[x for x in lst if not f(x)]]
records = [11,22,33,55,88,99]
bif_by(records,lambda x:x<50)

[[11, 22, 33], [55, 88, 99]]

54.map实现向量运算

lst1 = [1,2,3,4,5,6]
lst2 = [5,4,9,5,2,7]
list(map(lambda x,y:x*y+1,lst1,lst2))

[6, 9, 28, 21, 11, 43]

55.值最大的字典

def max_pairs(dic):
    if len(dic) == 0:
        return dic
    max_val = max(map(lambda v:v[1],dic.items()))
    return [item for item in dic.items() if item[1] == max_val]

r = max_pairs({'a': -10, 'b': 5, 'c': 3, 'd': 5})
print(r)

[('b', 5), ('d', 5)]

56.合并两个字典

def merge_dict2(dic1,dic2):
    return {**dic1,**dic2}
merge_dict2({'a': 1, 'b': 2}, {'c': 3})

{'a': 1, 'b': 2, 'c': 3}

dic1 = {'a': 1, 'b': 2, 'c': 3}
dic2 = {'d':4,'f':6}
{**dic,**dic2}

{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'f': 6}

57.top n字典

返回字典d前n个最大值对应的键

from heapq import nlargest

def topn_dict(d,n):
    return nlargest(n,d,key=lambda k:d[k])
topn_dict({'a': 10, 'b': 8, 'c': 9, 'd': 10}, 3)

['a', 'd', 'c']

58.异位词

检查两个字符串是否 相同字母异序词，简称：互为变位词

from collections import Counter

def anagram(str1,str2):
    return Counter(str1) == Counter(str2)

anagram('eleven+two', 'twelve+one')

True

59.合并字典

方法一：一般方法
该方法是重新生成一个新字典，改变merged中x元素的值，dic1中的x值不变

import sys

dic1 = {'x':1,'y':2}
dic2 = {'y':3,'z':4}
merged1 = {**dic1,**dic2}
print(f'merged1:{merged1}')
sys.getsizeof(merged1)

merged1:{'x': 1, 'y': 3, 'z': 4}
240

方法二：ChainMap

该方法是在内部创建一个容纳这些字典的列表，改变merged中元素的值，dic1中x值改变。 ChainMap 合并后的字典由于只是创建列表，其元
素只是指针变量（指向了原来的字典），占用字节自然会小很多

from collections import ChainMap
merged2 = ChainMap(dic1,dic2)
print(f'merged2:{merged2}')
sys.getsizeof(merged2)

merged2:ChainMap({'x': 1, 'y': 2}, {'y': 3, 'z': 4})
56