python语法总结

1、将列表、字符串、元组、字典组合成一个新的字符串：join()函数

语法：  'sep'.join(seq)

参数说明
sep：分隔符。可以为空
seq：要连接的元素序列、字符串、元组、字典
上面的语法即：以sep作为分隔符，将seq所有的元素合并成一个新的字符串

返回值：返回一个以分隔符sep连接各个元素后生成的字符串

2、拆分字符串：split()函数

split()：通过指定分隔符对字符串进行切片，并返回分割后的字符串列表（list）

语法：str.split(str="",num=string.count(str))[n]）

参数说明：
str：   表示为分隔符，默认为空格，但是不能为空('')。若字符串中没有分隔符，则把整个字符串作为列表的一个元素
num：表示分割次数。如果存在参数num，则仅分隔成 num+1 个子字符串，并且每一个子字符串可以赋给新的变量
[n]：   表示选取第n个分片
注意：当使用空格作为分隔符时，对于中间为空的项会自动忽略

如：

b=["1","0","1","0","1","0"]
b="".join(b).split("0") #先将列表中的元素组成一个字符串，然后split()将b中的0去掉。返回["1","1","1"]

3、对序列中的元素左同意操作：

如：

a=(1,0,3,0,5)
b=[str(i)for i in a]
print (b)

输出值:['1', '0', '3', '0', '5']

4、os模块主要是对文件属性的操作，对路径进行组合：os.path.join()函数：

语法：  os.path.join(path1[,path2[,......]])

返回值：将多个路径组合后返回

获取规范化的绝对路径：os.path.abspath()函数：

import os
path=os.path.join('hello','goodboy','doiido')

返回值为
'hello\goodboy\doiido'   #windows platform auto add \ between each string
'hello/goodboy/doiido'      #linux platform auto add / between each string

5、pycharm中无法加载存在__init__.py的文件夹时，可以在pycharm中将此文件夹添加到源文件中，也可以在程序开始添加：

import sys
sys.path.append('C:/Users/dsj/Desktop/open-dobot-1.3.0/application/python/dobot'))

这样就不会出现找不到模块的情况了

6、python string 类型 bytes类型 bytearray类型转换

1个字节=8位二进制位  1个字节=2位16进制位  1位进十六制位=4位二进制位。所以\xff为一个字节长度，\xf为占二进制的4个位

UTF-8编码方式中，英文字母用英文字母字节表示，一个汉字用三个十六进制字节表示

https://www.cnblogs.com/fieldtianye/p/8276552.html

https://www.cnblogs.com/gundan/p/8047315.html

https://blog.csdn.net/baidu_19473529/article/details/80042582

7、输出：print()与sys,stdout.write()

sys.stdout.write("hello"+'\n')
print("hello")
#两者在输出形式上是等价的,print()输出带回车，sys.stdout.write()输出没有回车。

8、读取数组中的名与内容：

list={'时间':3,"大小":5}
for file,data in list.items():
    print(file,data)

时间 3
大小 5

9、Python中的__init__()和__call__()函数

转自：https://blog.csdn.net/yaokai_assultmaster/article/details/70256621

在Python的class中有一些函数往往具有特殊的意义。__init__()和__call__()就是class很有用的两类特殊的函数。

__init__()

在Python中，__init__()函数的意义等同于类的构造器（同理，__del__()等同于类的析构函数）。因此，__init__()方法的作用是创建一个类的实例。

__call__()

Python中的函数是一级对象。这意味着Python中的函数的引用可以作为输入传递到其他的函数/方法中，并在其中被执行。
而Python中类的实例（对象）可以被当做函数对待。也就是说，我们可以将它们作为输入传递到其他的函数/方法中并调用他们，正如我们调用一个正常的函数那样。而类中__call__()函数的意义正在于此。为了将一个类实例当做函数调用，我们需要在类中实现__call__()方法。也就是我们要在类中实现如下方法：def __call__(self, *args)。这个方法接受一定数量的变量作为输入。
假设x是X类的一个实例。那么调用x.__call__(1,2)等同于调用x(1,2)。这个实例本身在这里相当于一个函数。

总结

那么，__init__()和__call__()的区别如下：
1. __init__()的作用是初始化某个类的一个实例。
2. __call__()的作用是使实例能够像函数一样被调用，同时不影响实例本身的生命周期（__call__()不影响一个实例的构造和析构）。但是__call__()可以用来改变实例的内部成员的值。

class X(object):
    def __init__(self, a, b, range):
        self.a = a
        self.b = b
        self.range = range
    def __call__(self, a, b):
        self.a = a
        self.b = b
        print('__call__ with （{}, {}）'.format(self.a, self.b))
    def __del__(self, a, b, range):
        del self.a
        del self.b
        del self.range


>>> xInstance = X(1, 2, 3)
>>> xInstance(1,2)
__call__ with (1, 2)

10、*self._args, **kwargs

*self._args 表示接受元组类参数；

**kwargs     表示接受字典类参数；

def foo(*args, **kwargs):
    print 'args = ', args
    print 'kwargs = ', kwargs
    print '---------------------------------------'
if __name__ == '__main__':
    foo(1,2,3,4)
    foo(a=1,b=2,c=3)
    foo(1,2,3,4, a=1,b=2,c=3)
    foo('a', 1, None, a=1, b='2', c=3)


输出结果如下：
args =  (1, 2, 3, 4) 
kwargs =  {} 
--------------------------------------- 
args =  () 
kwargs =  {'a': 1, 'c': 3, 'b': 2} 
--------------------------------------- 
args =  (1, 2, 3, 4) 
kwargs =  {'a': 1, 'c': 3, 'b': 2} 
--------------------------------------- 
args =  ('a', 1, None) 
kwargs =  {'a': 1, 'c': 3, 'b': '2'} 
---------------------------------------

可以看到，这两个是python中的可变参数。*args表示任何多个无名参数，它是一个tuple；**kwargs表示关键字参数，它是一个dict。并且同时使用*args和**kwargs时，必须*args参数列要在**kwargs前，像foo(a=1, b='2', c=3, a', 1, None, )这样调用的话，会提示语法错误“SyntaxError: non-keyword arg after keyword arg”。

11、使用os.path.abspath("")获取文件规范的绝对路径，加载的模块的路径都在sys.path中储存，在调用其他文件或文件中的模块时，可以将文件路径加到sys.path中，通过sys.path.append("路径")，这样就可以在程序中调用文件包或者加载文件中的模块了。

12、获取类中所有属性

在类中添加这个脚本，直接在定义的对象中调用这个脚本即可得到类中所有属性。
    def display(self):
        """Display Configuration values."""
        print("\nConfigurations:")
        for a in dir(self):
            if not a.startswith("__") and not callable(getattr(self, a)):
                print("{:30} {}".format(a, getattr(self, a)))
        print("\n")


#dir()返回的是一个字符串
dir()是Python提供的一个API函数，dir()函数会自动寻找一个对象的所有属性(包括从父类中继承的属性)。
一个实例的__dict__属性仅仅是那个实例的实例属性的集合，并不包含该实例的所有有效属性。所以如果想获取一个对象所有有效属性，应使用dir()。

13、返回一个对象属性值 getattr().

getattr() 函数用于返回一个对象属性值。

getattr 语法：

getattr(object, name[, default])

• object -- 对象。
• name -- 字符串，对象属性。
• default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。

14、startswith()

方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。

startswith()方法语法：

str.startswith(str, beg=0,end=len(string));

• str -- 检测的字符串。
• strbeg -- 可选参数用于设置字符串检测的起始位置。
• strend -- 可选参数用于设置字符串检测的结束位置。

返回值

如果检测到字符串则返回True，否则返回False。

#实例以下实例展示了startswith()函数的使用方法：
str = "this is string example....wow!!!";
print str.startswith( 'this' );
print str.startswith( 'is', 2, 4 );
print str.startswith( 'this', 2, 4 );
以上实例输出结果如下：
True
True
False

 15、读取文件下的文件

file_names = next(os.walk(IMAGE_DIR))[2]
image = skimage.io.imread(os.path.join(IMAGE_DIR, random.choice(file_names)))


file_name为IMAGE_DIR文件夹下的文件

16、next（）函数

next函数是python的内置函数。

list、tuple等都是可迭代对象，我们可以通过iter()函数获取这些可迭代对象的迭代器。然后我们可以对获取到的迭代器不断使⽤next()函数来获取下⼀条数据。iter()函数实际上就是调⽤了可迭代对象的 __iter__   ⽅法。
li = [11,22,33,44,55]
li_iter=iter(li)
print(next(li_iter) )11
print(next(li_iter) )22
print(next(li_iter) )33
print(next(li_iter) )44
print(next(li_iter) )55
print(print（ next(li_iter))

Traceback(most recent call last):File "<stdin>", line1,in module> StopIteration

注意，当我们已经迭代完最后⼀个数据之后，再次调⽤next()函数会抛出
StopIteration的异常，来告诉我们所有数据都已迭代完成，不⽤再执⾏
next()函数了。

17、os.walk()寻遍文件夹下的文件与文件夹

import os

g = os.walk(r'D:\Users\Quincy_C\PycharmProjects\S6')
print(next(g))
print(next(g))12345

第一次next结果：得到的结果是是一个元组，元组的第一个元素是输入的文件路径，第二个元素是当前路径下所有的文件夹组成的列表，第三个元素是当前路径下所有文件组成的列表：
 
(‘D:\Users\Quincy_C\PycharmProjects\S6’, [‘.idea’,  ‘socket并发’, ‘socket编程’, ‘pycache‘, ‘互斥锁’,  ‘并发’, ‘序列化与反序列化’], [‘logging模块.py’, ‘os.walk()用法.py’])

第二次next结果：
(‘D:\Users\Quincy_C\PycharmProjects\S6\.idea’, [‘inspectionProfiles’, ‘scopes’], [‘.name’, ‘encodings.xml’, ‘misc.xml’, ‘modules.xml’, ‘S6.iml’, ‘vcs.xml’, ‘workspace.xml’]) 
这次会进到当前文件夹下的第一个子文件夹进行遍历，得到第一个子文件夹路径以及该子文件夹下的文件夹和文件
依次类推=—>
获取文件的绝对路径：
import os
g = os.walk(r'D:\Users\Quincy_C\PycharmProjects\S6')
for par_dir, _, files in g:
    for file in files:
        filepath = os.path.join(par_dir, file)
        print(filepath)
# D:\Users\Quincy_C\PycharmProjects\S6\.idea\encodings.xml

18、定义函数时，参数中有：*  和**。

如*args和**kwargs只是一种约定俗成的编程实践。我们也可以写成*vars和**kvars。

*args的使用
*args用来表示函数接收可变长度的非关键字参数列表作为函数的输入。我们可以通过以下这个例子来进一步理解*args。

def test_args(normal_arg, *args):
    print("first normal arg:" + normal_arg)
    for arg in args:
        print("another arg through *args :" + arg)

test_args("normal", "python", "java", "C#")
上面代码的执行结果如下：

first normal arg: normal
another arg through *args : python
another arg through *args : java
another arg through *args :C#

**kwargs的使用
**kwargs表示函数接收可变长度的关键字参数字典作为函数的输入。当我们需要函数接收带关键字的参数作为输入的时候，应当使用**kwargs。我们可以通过以下这个例子来进一步理解**kwargs。 

def test_kwargs(**kwargs):
    if kwargs is not None:
        for key, value in kwargs.iteritems():
            print("{} = {}".format(key,value))
        # Or you can visit kwargs like a dict() object
        # for key in kwargs:
        #    print("{} = {}".format(key, kwargs[key]))
test_kwargs({“name”："python”, “value”：5})
以上代码的执行结果如下：

name = python
value = 5
以上例子只是*args和**kwargs的基本的使用例子。下面再给出一个用*args和**kwargs来定义能够接收列表输入和字典输入的函数的例子。

19、更新类中数组：

数组名.update(另一数组名)

    def add_image(self, source, image_id, path, **kwargs):
        image_info = {
            "id": image_id,
            "source": source,
            "path": path,
        }
        image_info.update(kwargs)
        self.image_info.append(image_info)

#self.image_info是类中的属性。image_info是函数中的变量，不一样
# image_info.update(kwargs)...update(kwargs)将数组更新，如果关键名一样，只更新他的值，如果
#kwargs中的关键字在image_info中不存在，则添加到image_info中

20、去重

ids = [1,4,3,3,4,2,3,4,5,6,1]
news_ids = list(set(ids))
news_ids.sort(key=ids.index) 
print(news_ids)

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

21、向列表中添加元素。

list.append(object) 向列表中添加一个对象object
list.extend(sequence) 把一个序列seq的内容添加到列表中

1 2 3 4 5

music_media = ['compact disc', '8-track tape', 'long playing record'] new_media = ['DVD Audio disc', 'Super Audio CD'] music_media.append(new_media) print music_media >>>['compact disc', '8-track tape', 'long playing record', ['DVD Audio disc', 'Super Audio CD']]

使用append的时候，是将new_media看作一个对象，整体打包添加到music_media对象中。

1 2 3 4 5

music_media = ['compact disc', '8-track tape', 'long playing record'] new_media = ['DVD Audio disc', 'Super Audio CD'] music_media.extend(new_media) print music_media >>>['compact disc', '8-track tape', 'long playing record', 'DVD Audio disc', 'Super Audio CD']

使用extend的时候，是将new_media看作一个序列，将这个序列和music_media序列合并，并放在其后面。

22、*.shape[-1]的用法

*必须是bool型序列，返回序列最后一维的维度值。

import numpy as np
m=np.zeros((3,3,5),dtype=bool)
print(m.shape[-1])

output:5
对于其他类型的序列，没有这shape属性

23、返回一个bool型多维序列中True的横纵坐标

m为bool型序列。
horizontal_indicies = np.where(np.any(m, axis=0))[0]
vertical_indicies = np.where(np.any(m, axis=1))[0]

24、np.any(m, axis=0)相当于对序列的第0维做或运算。m为bool型。np.all（m, axis=0）相当于做与运算。

n=[[False ,True, False ,False, False],-----》True
 [False ,False ,True,False, False],-----》True
 [False, False ,False ,True, False]]-----》True
    | 
    False  True  True  True False 

print(np.any(n, axis=1))
print(np.any(n, axis=0))

output：[ True  True  True]
        [False  True  True  True False]

25、np.where(n)[0]返回序列n在0维上为True的元素的下标。

import numpy as np
n=[False,True,False,True,False]
h=np.where(n)[0]
print(h)
#output:[1 3]

---------------另一个重要用法------------------
np.where(confition,x,y)

如果confition为True，则执行x，为False则执行y。

26、返回一个1维列表的第一个值和最后一个值list[[0,-1]]

想一次性取一个列表中的多个数，可以用list[[1,2,3,-1]]

取得是下标为1，2，3，-1的元素

27、将两组数据每个数据一一组成一组

import numpy as np

x = np.array([1,2,3])
y = np.array([4,5,6,7])
xv,yv = np.meshgrid(y,x,indexing = 'xy')
xv2,yv2 = np.meshgrid(x,y,indexing = 'ij')
print(xv)
print(yv)
print(xv.flatten())
print(yv.flatten())

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

28、生成器

https://www.cnblogs.com/coder2012/p/4990834.html

yield的功能类似于return，但是不同之处在于它返回的是生成器。

生成器是通过一个或多个yield表达式构成的函数，每一个生成器都是一个迭代器（但是迭代器不一定是生成器）。

如果一个函数包含yield关键字，这个函数就会变为一个生成器。

生成器并不会一次返回所有结果，而是每次遇到yield关键字后返回相应结果，并保留函数当前的运行状态，等待下一次的调用。

由于生成器也是一个迭代器，那么它就应该支持next方法来获取下一个值。

应用

最经典的例子，生成无限序列。

常规的解决方法是，生成一个满足要求的很大的列表，这个列表需要保存在内存中，很明显内存限制了这个问题。

def get_primes(start):
    for element in magical_infinite_range(start):
        if is_prime(element):
            return element

如果使用生成器就不需要返回整个列表，每次都只是返回一个数据，避免了内存的限制问题。 

def get_primes(number):
    while True:
        if is_prime(number):
            yield number
        number += 1

 29、a[(b>0)&(b<0)]=2

a中是一个与a同型的bool型数组，将True的位置赋2.

import numpy as np

a= np.zeros([5], dtype=np.int32)
b=np.array([1,2,3,4,5])
c=np.array([5,6,7,8,9])
print((b<3)&(c<8))
a[(b<3)&(c<8)]=-2
print(a)

[ True  True False False False]
[-2 -2  0  0  0]

30、np.random.randint(10,50,(10,2))

官方文档中给出的用法是：numpy.random.randint(low,high=None,size=None,dtype) 
生成在半开半闭区间[low,high)上离散均匀分布的整数值;若high=None，则取值区间变为[0,low) 

import numpy as np
a=np.random.randint(10,50,(4,2))
print(a)

[[46 21]
 [33 32]
 [11 33]
 [34 38]]

31、通过选择GPU与CPU来训练网络

https://blog.csdn.net/u010238520/article/details/76165736

https://blog.csdn.net/dcrmg/article/details/79747882