PYTHON语法学习

1、用PYTHON实现排列组合

笛卡尔积：itertools.product(*iterables[, repeat])

直接对自身进行笛卡尔积：

import itertools

for i in itertools.product('ABCD', repeat = 2):

print (''.join(i),end=' ')

输出结果：

AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD

print (‘’.join(i))这个语句可以让结果直接排列到一起

end=’’ 可以让默认的输出后换行变为一个空格

两个元组进行笛卡尔积：

import itertools

a = (1, 2, 3)

b = ('A', 'B', 'C')

c = itertools.product(a,b)

for i in c:

print(i,end=' ')

输出结果：

(1, ‘A’) (1, ‘B’) (1, ‘C’) (2, ‘A’) (2, ‘B’) (2, ‘C’) (3, ‘A’) (3, ‘B’) (3, ‘C’)

排列：itertools.permutations(iterable[, r])

import itertools

for i in itertools.permutations('ABCD', 2):

print (''.join(i),end=' ')

输出结果：

AB AC AD BA BC BD CA CB CD DA DB DC

组合：itertools.combinations(iterable, r)

import itertools

for i in itertools.combinations('ABCD', 3):

print (''.join(i))

输出结果：

ABC

ABD

ACD

BCD

组合（包含自身重复）：itertools.combinations_with_replacement(iterable, r)

import itertools

for i in itertools.combinations_with_replacement('ABCD', 3):

print (''.join(i),end=' ')

输出结果：

AAA AAB AAC AAD ABB ABC ABD ACC ACD ADD BBB BBC BBD BCC BCD BDD CCC CCD CDD DDD

2、join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

str.join(sequence)              sequence -- 要连接的元素序列。

str.join(元组、列表、字典、字符串) 之后生成的只能是字符串。

所以很多地方很多时候生成了元组、列表、字典后，可以用 join() 来转化为字符串。

3、按逗号分隔列表

方法一：

def commaSpiltList(self, listData):

        listData = list(listData)

        strs = str(listData[0])

        for letter in range(1, len(listData) - 1):

            strs = strs + ',' + str(listData[letter])

        strs += ',' + str(listData[len(listData) - 1])

        print(strs)

方法二：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

L = [1,2,3,4,5]

s1 = ','.join(str(n) for n in L)

print s1

4、复制

—–深复制，即将被复制对象完全再复制一遍作为独立的新个体单独存在。所以改变原有被复制对象不会对已经复制出来的新对象产生影响。

—–而等于赋值，并不会产生一个独立的对象单独存在，他只是将原有的数据块打上一个新标签，所以当其中一个标签被改变的时候，数据块就会发生变化，另一个标签也会随之改变。

—–而浅复制要分两种情况进行讨论：

1）当浅复制的值是不可变对象（数值，字符串，元组）时和“等于赋值”的情况一样，对象的id值与浅复制原来的值相同。

2）当浅复制的值是可变对象（列表和元组）时会产生一个“不是那么独立的对象”存在。有两种情况：

第一种情况：复制的 对象中无 复杂 子对象，原来值的改变并不会影响浅复制的值，同时浅复制的值改变也并不会影响原来的值。原来值的id值与浅复制原来的值不同。

第二种情况：复制的对象中有 复杂 子对象 （例如列表中的一个子元素是一个列表），如果不改变其中复杂子对象，浅复制的值改变并不会影响原来的值。 但是改变原来的值 中的复杂子对象的值  会影响浅复制的值。

对于简单的 object，例如不可变对象（数值，字符串，元组），用 shallow copy 和 deep copy 没区别

复杂的 object， 如 list 中套着 list 的情况，shallow copy 中的 子list，并未从原 object 真的「独立」出来。也就是说，如果你改变原 object 的子 list 中的一个元素，你的 copy 就会跟着一起变。这跟我们直觉上对「复制」的理解不同。