基本语法
丹丹
 2019-06-23 00:00:00    1.9k Words  11 Mins  

数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
print("===一维数组===")
print([i * 2 for i in range(10)])
print([i * i for i in range(10)])
print([i * i for i in range(10) if (i % 3) == 0])
print([(x, y) for x in range(3) for y in range(3)])
print('')

print("===二维数组===")
a = [[3] * (i + 1) for i in range(3)]
print(a[2])
print('')

print("===乘法的问题===")
a = [[1, 2, 3]] * 3
a[1][1] = 100
print(a)
print('')

print("===解决方法===")
a = [[1, 2, 3] for i in range(3)]
a[1][1] = 100
print(a)

===一维数组===
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[0, 9, 36, 81]
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

===二维数组===
[3, 3, 3]

===乘法的问题===
[[1, 100, 3], [1, 100, 3], [1, 100, 3]]

===解决方法===
[[1, 2, 3], [1, 100, 3], [1, 2, 3]]

字典

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
print("===初始化===")
d = {'a':1, 2:'b', 'c':3, 4:'d'}
print(d)
print('')

print("===获取长度===")
print(len(d))
print('')

print("===根据key读写===")
d['a'] = 100
d[4] = 'dd'
print(d)
print('')

print("===添加元素===")
d['e'] = 5
d[6] = 'f'
print(d)
print('')

print("===删除元素===")
d = {'a':1, 2:'b', 'c':3, 4:'d'}
del(d['a'])
del(d[2])
print(d)
print('')

print("===判断key是否存在===")
d = {'a':1, 2:'b', 'c':3, 4:'d'}
if 'a' in d:
    print('a in d')
if 2 in d:
    print('2 in d')
if not ('x' in d):
    print('x not in d')
print('')

print("===判断字典是否为空===")
d = {}
if not d:
    print('d is empty')
print('')

print("===遍历===")
d = {'a':1, 2:'b', 'c':3, 4:'d'}
for k in d.keys():
    print(str(k) + ': ' + str(d[k]))
for k, v in d.items():
    print(str(k) + ': ' + str(v))

===初始化===
{'a': 1, 2: 'b', 'c': 3, 4: 'd'}

===获取长度===
4

===根据key读写===
{'a': 100, 2: 'b', 'c': 3, 4: 'dd'}

===添加元素===
{'a': 100, 2: 'b', 'c': 3, 4: 'dd', 'e': 5, 6: 'f'}

===删除元素===
{'c': 3, 4: 'd'}

===判断key是否存在===
a in d
2 in d
x not in d

===判断字典是否为空===
d is empty

===遍历===
a: 1
2: b
c: 3
4: d
a: 1
2: b
c: 3
4: d

集合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
print("===初始化===")
s_a = set([1, 2, 3, 4, 5])
s_b = set([1, 1, 2, 2, 3, 4, 5])
print(s_a)
print(s_b)
print('')

print("===获取长度===")
print(len(s_a))
print(len(s_b))
print('')

print("===添加元素===")
s_a.add(6)
s_a.add(6)
s_a.update([5, 6, 7, 8, 9])
print(s_a)
print('')

print("===删除元素===")
s_a.remove(8)
s_a.remove(9)
print(s_a)
print('')

print("===判断元素是否存在===")
print(1 in s_a)
print(10 in s_a)
print('')

print("===判断集合是否为空===")
s_a = set([])
if not s_a:
    print('set is empty')
else:
    print('set is not empty')
print('')

print("===遍历===")
s_a = set([1, 2, 3, 4, 5])
for i in s_a:
    print(i)
print('')

print("===集合操作===")
s_a = set([1, 2, 3, 4, 5])
s_b = set([4, 5, 6, 7, 8])

print("===并集===")
print(s_a | s_b)
print(s_a.union(s_b))
print("")

print("===交集===")
print(s_a & s_b)
print(s_a.intersection(s_b))
print("")

print("===差集 s_a - (s_a and s_b)===")
print(s_a - s_b)
print(s_a.difference(s_b))
print("")

print("===对称差===")
print(s_a ^ s_b)
print((s_a | s_b) - (s_a & s_b))
print(s_a.symmetric_difference(s_b))
===初始化===
{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5}

===获取长度===
5
5

===添加元素===
{1, 2, 3, 4, 5, 6, 7, 8, 9}

===删除元素===
{1, 2, 3, 4, 5, 6, 7}

===判断元素是否存在===
True
False

===判断集合是否为空===
set is empty

===遍历===
1
2
3
4
5

===集合操作===
===并集===
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 3, 4, 5, 6, 7, 8}

===交集===
{4, 5}
{4, 5}

===差集 s_a - (s_a and s_b)===
{1, 2, 3}
{1, 2, 3}

===对称差===
{1, 2, 3, 6, 7, 8}
{1, 2, 3, 6, 7, 8}
{1, 2, 3, 6, 7, 8}

列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
print("===初始化列表===")
li = [1, 2, 3, 'abc', 4.5, [2, 3, 4], {1:'one'}]

print("===获取长度===")
print(len(li))
print('')

print("===根据索引读写===")
print(li[0])
print(li[3])
print(li[-1])
print('')

print("===添加元素===")
li = [1, 2, 3]
li.append('a')
li.append('b')
print(li)
li.append([4, 5, 6])
print(li)
li = [1, 2, 3]
li.extend([4, 5, 6])
print(li)
print('')

print("===删除元素===")
li = [1, 2, 3, 4, 5]
li.pop()
print(li)
del(li[0])
del(li[1])
print(li)
print('')

print("===元素是否存在===")
li = [1, 2, 3, 4, 5]
print(1 in li)
print(6 in li)
print('')

print("===列表是否为空===")
li = []
if not li:
    print('Empty')
else:
    print('Not empty')
print('')

print("===字符串===")
s = 'abcdefg'
li = list(s)
li[4] = 'E'
li[5] = 'F'
print(li)
s = ''.join(li)
print(s)
print('')

print("===遍历===")
li = [1, 2, 3]
for i in li:
    print(i)
for i in range(len(li)):
    print(li[i])

===初始化列表===
===获取长度===
7

===根据索引读写===
1
abc
{1: 'one'}

===添加元素===
[1, 2, 3, 'a', 'b']
[1, 2, 3, 'a', 'b', [4, 5, 6]]
[1, 2, 3, 4, 5, 6]

===删除元素===
[1, 2, 3, 4]
[2, 4]

===元素是否存在===
True
False

===列表是否为空===
Empty

===字符串===
['a', 'b', 'c', 'd', 'E', 'F', 'g']
abcdEFg

===遍历===
1
2
3
1
2
3

切片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
li = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print("===切片===")
print(li[2:5])
print(li[:4])
print(li[5:])
print(li[:])
print(li[0:6:2])
print(li[3::2])
print('')

print("===负数索引和step===")
print(li[::-1])
print(li[::-2])
print(li[-6:-1:1])
print(li[-1::-1])
===切片===
[2, 3, 4]
[0, 1, 2, 3]
[5, 6, 7, 8, 9, 10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[0, 2, 4]
[3, 5, 7, 9]

===负数索引和step===
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
[10, 8, 6, 4, 2, 0]
[5, 6, 7, 8, 9]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

json处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import json

print("===dict与json互转===")
d = {'Python':100, 'C++':70, 'Basic':60, 'others':{'C':65, 'Java':50}}
jtxt = json.dumps(d)
dd = json.loads(jtxt)
print(jtxt)
print(dd)
print('')

print("===用json序列化非dict对象===")
class Student:
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score

    def __str__(self):
        return '%s: %d, %d' % (self.name, self.age, self.score)

s = Student('Tom', 15, 85)
print(s)
print(s.__dict__)
print("")

print("===方法1===")
jtxt = json.dumps(s, default = lambda obj: obj.__dict__)
print(jtxt)
def d2s(d):
    return Student(d['name'], d['age'], d['score'])
print(json.loads(jtxt, object_hook = d2s))
print("")

print("===方法2===")
def s2d(s):
    return s.__dict__
jtxt = json.dumps(s, default = s2d)
print(jtxt)

===dict与json互转===
{"Python": 100, "C++": 70, "Basic": 60, "others": {"C": 65, "Java": 50}}
{'Python': 100, 'C++': 70, 'Basic': 60, 'others': {'C': 65, 'Java': 50}}

===用json序列化非dict对象===
Tom: 15, 85
{'name': 'Tom', 'age': 15, 'score': 85}

===方法1===
{"name": "Tom", "age": 15, "score": 85}
Tom: 15, 85

===方法2===
{"name": "Tom", "age": 15, "score": 85}

class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class MyClass:
    def __init__(self, val):
        self.val = val

    def display(self, s):
        print('%s: %d' % (s, self.val))

m = MyClass(100)
print(m.val)
m.display('hello')
print('')

m2 = m
print(id(m))
print(id(m2))

fn = m.display
fn('hey')
100
hello: 100

4539482520
4539482520
hey: 100

generator

1
2
3
4
5
6
7
8
9
10
11
def fab(max): 
    n, a, b = 0, 0, 1 
    while n < max: 
        yield b 
        # print b 
        a, b = b, a + b 
        n = n + 1
    return n
        
for n in fab(5):
    print(n)
1
1
2
3
5

参考：

  1. 廖雪峰Python数据分析
  2. yield讲解