python基础知识1

发表于 | 分类于 | 评论数： | 阅读次数：
|

本文主要是整理python的基本类型，包括列表、元组、字典、字符串、bytes和集合（set）的基本操作和应用。

1. list

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
68
### list：可变，可索引，有序（可索引），元素可重复，使用[]表示

lst = [1,3,'a',('a','b'),'mykernel']

#修改
lst[2] = 'good'
print('1.',lst)
#追加
lst.append('end str')
print('2.',lst)
#插入
lst.insert(3,'gogogog')
print('3.',lst)
#扩展新列表
lst2= ["new","list"]
lst.extend(lst2)
print('4.',lst)
tup = ('a','b')
lst.extend(tup)
print('5.',lst)
# + => list
# * => list，重复
new_list = [1,2]
old_list= [1]
new1= new_list+old_list
print('6.',new1)
new2= new_list*3
print('7.',new2)
#移除,移除找到的第一个，移除所有的如何写？
new2.remove(1)
print('8.',new2)
new2.pop(3) #移除索引为3的
print('9.',new2)
#清空
new2.clear()
#反转
lst.reverse()
print('9.',lst)
#排序
l = [1,1,2,-100]
l.sort()
print('10.',l)

### 进阶
#列表复制,浅拷贝
lst = [1,2,3,4,11,'a',[1,2,4]]
lst1 = lst
lst2 = lst.copy()
lst[6][1] = '1'
print('11.',lst1,'\n   ',lst2)  #原引用里的值改变，新列表也会变

#深拷贝
import copy
lst0 = [1,[2,3,4],5]
lst5 = copy.deepcopy(lst0)
lst0[1][1] = 21
print('12.',lst0,'\n   ',lst5) #lst0 != lst5

#随机数
import random
#从[0-9] 中随机挑选一个值
print('13,',random.randint(0,9))
print('14,',random.choice(range(10)))

#打乱列表
lst6 = copy.deepcopy(lst)
random.shuffle(lst6)
print('15.',lst,'\n   ',lst6)

求100以内的素数

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
# The first solution
import math
p1=[2,3,5,7]
n = 100 
for x in range(10,n):
    for i in range(2,math.ceil(math.sqrt(x))):
        if x % i == 0:
            break
    else:
        p1.append(x)
print(p1)

#The second solution
#合数一定可以分解成几个质数的乘积
import math
n = 100
lst = []
for x in range(2,n): 
    for i in lst: 
        if x % i ==0:
            break
    else:
        lst.append(x)
print(lst)

## optimize code
# 带flag判断，提高程序效率。
import math
lst = [2]
flag = False
for x in range(2,100): #x=13
    for i in p:   #p=[2,3,5,7]
        if x % i ==0:  # x%i != 0 
            flag = True
            break
        if i >= math.ceil(math.sqrt(x)): #i< math.ceil(math.sqrt(x))
            flag = False
            break
    if not flag: #flag = false  ==> true
         lst.append(x)
print(lst)

打印杨辉三角（ Pascal’s triangle）

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
68
69
70
71
72
73
# The first solution
# 下一行和上一行的关系

triangle = [[1],[1,1]]
for i in range(2,6):
    cur = [1]
    pre = triangle[i-1]
    for j in range(len(pre)-1):
        cur.append(pre[j]+pre[j+1])
    cur.append(1)
    triangle.append(cur)
print(triangle)

#The second solution
triangle = []
n =6 
for i in range(n):
    row = [1]
    triangle.append(row)
    if i == 0:
        continue
    for j in range(i-1):
        row.append(triangle[i-1][j]+triangle[i-1][j+1])
    row.append(1)
print(triangle)

#Third option ,while
n = 6 
oldline = []
newline = [1]
print(newline)
length = 0 
for i in range(1,n):
    oldline = newline.copy()
    oldline.append(0)
    newline.clear()
    offset = 0 
    while offset <= i:
        newline.append(oldline[offset-1]+ oldline[offset])
        offset +=1
    print(newline)
    
#Third option ,for 
n = 6 
oldline = []
newline = [1]
print(newline)
length = 0 
for i in range(1,n):
    oldline = newline.copy()
    oldline.append(0)
    newline.clear()
    for j in range(i+1):
        newline.append(oldline[j-1]+ oldline[j])
    print(newline)

#Option 4

triangle = []
n = 6

for i in range(n):
    row = [1]*(i+1)
    triangle.append(row)
    if i == 0:
        continue
        
    for j in range(1,i//2+1): #n=3 开始
        val = triangle[i-1][j-1] + triangle[i-1][j]
        row[j] = val
        if i !=2j: #奇数个数的中点跳过
            row[-j-1] = val
print(triangle)

2. 元组

1
2
3
4
5
6
# 元组有序（可索引），不可变，小括号()表示，可以重复，只读（不能增删改）
## 对比 list：有序（可索引），可变，使用[]表示，元素可重复
# 定义
print(tuple())
print((2,2))
print(tuple(range(1,7,2)))
1
2
3
4
5
6
7
8
9
10
t = (1,(2,),'a',[1,2],1,2,2,2,1,1,1)
print('1,',(t.index(1))) #返回找到的第一个的索引
print('2,',t.count(1)) #返回value的个数
print('3,',len(t))  #长度

#命名元组
from collections import namedtuple
point = namedtuple('_point',['x','y'])
p = point(21,12)
print('4,',p.x,p.y)

冒泡法排序

1
2
3
4
5
6
7
8
# 对列表[1,9,8,5,6,7,4,3,2]使用冒泡法进行排序，要求使用封装和解构来交换数据

lst = [1,9,8,5,6,7,4,3,2]
for i in range(len(lst)):
    for j in range(8-i):
        if lst[j]>lst[j+1]: #靠前位置的值大于靠后位置的值，前位置获取小的值。
            lst[j],lst[j+1]=lst[j+1],lst[j]
print(lst)

3. 字符串

1
2
3
# 元组有序（可索引），不可变，小括号()表示，可以重复，只读（不能增删改）
## 对比 list：有序（可索引），可变，使用[]表示，元素可重复
### 字符串是不可变的，有序，使用引号（单双，单双三）
1
2
3
4
5
6
7
8
9
str = "my name is mykernel"
lst = []

for i in str:
    lst.append(i)
print(lst)

lst2 = list(str)
print(lst2)
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
#其他相关操作
## split
print('1,','l love python'.split())
# split()的()中指定分隔符
# 默认使用空格作为分隔符

# maxsplit=# 可以指定分隔的次数。
print('2,','my name is  mykernel'.split('m',maxsplit=1))

##rsplit
#分隔符可以是任意字符串。
print('3,','my name is  mykernel'.rsplit('m',maxsplit=1))

#当不用maxsplit= 时候，split和rsplit效果一样，但是split效率更高。

##splitlines
l = """l love python
i am mykernel
"""
print('4,',l.splitlines())

##partition
l = """l love python"""
print('5,',l.partition(' '))

#partition() 不能不传入分隔符，只分隔一次，打印内容，为前半部分、分隔符和后半部分.

print('#'*20,'大小','#'*20) 

#upper
l = """l love python""" #转大写
l2= l.upper()
print('5,',l2)
#lower
l3 = l2.lower()  #转小写
print('6,',l3)

print('#'*20,'替换','#'*20)  
#replace 替换
str = 'i love python'
print('7,',str.replace('love python','am mykernel') ) #前边是旧的字符串，后边是新的字符串。
#控制替换的个数
str = 'i very very very love python '
print('8,',str.replace('very','非常',2))  #替换2个
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
print('#'*20,'去除','#'*20) 
#strip 去掉
str = '   mykernel   love  python   \n'
str2 = str.strip()
#strip 可以加其他字符串，意思就是去掉两端可以匹配到的对应的字符串
print('9,',str2)

#lstrip()只移除左侧部分;
#rstrip()只移除右侧部分。
print('#'*20,'填充','#'*20) 
print('10,','mykernel'.ljust(30))
print('10,','mykernel'.rjust(30))
print('10,','mykernel'.center(30))  #一边15个。。。。

print('11,','mykernel'.ljust(30,'+'))
print('11,','mykernel'.rjust(30,'#'))
print('11,','mykernel'.center(30,'*'))  #一边15个。。。。

print('#'*20,'查找','#'*20) 
#find() 查找返回找到的第一个的索引
str = 'i very very very love python '
print('12,',str.find('very'))
print('12,',str.find('very',5))
print('12,',str.rfind('very',4))
print('12,',str.rfind('very',-20,-1))

#index(sub[, start[, end]])
#在指定的区间，从左到右。找到返回对应的索引值，没找到返回ValueError。

#rindex(sub[, start[, end]])
#在指定的区间，从右到左。找到返回对应的索引值，没找到返回ValueError。

#count 在指定的区间，从左到右，统计子字符串sub出现的次数
str = 'i very very very love python '
print('13,',str.count('very')) 
print('13,',str.count('very',5))
print('13,',str.count('very',5,11))
1
2
3
4
5
6
7
8
9
10
11
12
#判断
#startwith()
str = 'i am mykernel,i very very very love python'
print(str.startswith('am'))
print(str.startswith('i'))

## 也可以指定范围进行匹配。
print(str.startswith('am',2,20)) #（2,20]
#endswith()
str = 'i am mykernel,i very very very love python'
print(str.endswith('am'))
print(str.endswith('python'))
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
print('#'*20,'拼接','#'*20) 
# +
print('1,','i'+' love'+' python')
# join
print('2,',' '.join(['i'+' love'+' python']))

print('#'*20,'格式化','#'*20) 
s = 'i love %s' #%s为格式占位符，然后再其他地方可以将参数传入并替换该占位符。
s1 = s%('python',) #将python传入，替换占位符。
print('3,',s1)

##format字符串格式化
#a. format方法可以使用花括号作为占位符，传入的参数将替换花括号。
s = 'i love {}' #{}作为占位符
s1 = s.format('python')
print('4,',s1)
# format方法的参数可以为多个，如果不在括号里指定其位置一一对应引入。
s ='i love {}, i am {}'
s1 = s.format('python','mykernel')  #按照位置传入
print('5,',s1)
# format方法可以在花括号里填入位置数字，其后的参数按照位置引入，从0号位置开始
s ='i love {1}, i am {0}'
s1 = s.format('python','mykernel')
print('6,',s1)
s ='i love {0}, i am {0}'
s1 = s.format('python','mykernel')
print('7,',s1)

#format方法可以用字符作为占位符的标志，方便识别。
s1='i love {language},i am {name}'.format(language='python',name='mykernel')
print('8,',s1)

#format方法的占位符可以混用，但是位置参数必须放在最前。
s1 = 'my name is {0},i love {language},i am {age}'.format('mykernel',language='pyrhon',age=18)
print('9,',s1)

说明1：

占位符的个数大于参数个数的时候，会抛出异常IndexError。
占位符的个数小于参数个数的时候，若对应的占位符能匹配到值则不报错，匹配不到值会返回异常。
当占位符出现混用的情况时，位置参数不在最前会返回异常。
说明2：

通常使用2.6或之后的版本使用format方法，2.6之前使用printf style。
在format中，需要注意的是，在2.6版本中是不能省略大括号里面的数字或者关键字。
字符串对齐

1
2
3
4
5
print('{0}*{1}={2:<4}'.format(3,2,2*3))  #右边4个空格
print('{0}*{1}={2:>4}'.format(3,2,2*3))
print('{0}*{1}={2:<04}'.format(3,2,2*3))
print('{:^30}'.format('centered'))  #左右各30个空格
print('{:*^30}'.format('centered'))
1
2
3
4
5
6
7
8
## 演变过程
print('{}'.format(1))
#右对齐
print('{:>8}'.format(1))

print('{:^{}}'.format(1,11))

#格式填充^、<、>分别是居中、左对齐、右对齐，后面带宽度

4. bytes和bytearray

1
2
3
4
# 元组有序（可索引），不可变，小括号()表示，可以重复，只读（不能增删改）
## 对比 list：有序（可索引），可变，使用[]表示，元素可重复
### 字符串是不可变的，有序，使用引号（单双，单双三）
#### bytes是不可变的字节序列，bytearray是可变的字节序列
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
# str -> bytes
str = 'abc'
bys = str.encode()
print(bys)

#bytes -> str
str1 = bys.decode()
print(str1)

#生成bytearray
bar = bytearray(1)
bar1 = bytearray(b'123')
print(bar,bar1)

#bytearray的相关方法

b = bytearray()
b.append(97)
b.append(99)
b.insert(1,98)
b.extend([65,66,67])
b.extend(bytearray(b'aavv'))
print(b)
b.remove(66)
print(b)
b.pop()
print(b)
b.reverse()
print(b)
b.clear()
print(b)

字符串转16进制

1
bytearray('abc'.encode()).hex()
'616263'

5. set

1
2
3
4
5
# 元组有序（可索引），不可变，小括号()表示，可以重复，只读（不能增删改）
## 对比 list：有序（可索引），可变，使用[]表示，元素可重复
### 字符串是不可变的，有序，使用引号（单双，单双三）
#### bytes是不可变的字节序列，bytearray是可变的字节序列
##### set叫集合，元素可变（元素需要可hash）、无序（无法索引,可以迭代）、不重复（去重？？）
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
#定义
s1 = {(1,),1,'1',b'1'}
print('1,',s1)

#增加元素,元素存在则什么都不做
s1.add('a')
print('2,',s1)

s1.update([1,2,3,4])  #update中为可迭代对象即可
print('3,',s1)
s1.update('str 11')  #注意字符串一个字符算一个元素
print('4,',s1)

#删除
s1.remove(1) #移除的元素不存在 报错
print('5,',s1)  
s1.discard('1') #移除的元素不存在  不报错
print('6,',s1)
print(s1.pop()) # -> item ,任意移除一个元素，s1为空报错
print('7,',s1)

#清除
s1.clear()
print('8,',s1)

#其他
#1. set 不能修改
#2. set 非线性结构不能查询
#3. set 无序，但是可以for in 迭代，无法索引

#可以使用in 或者 not in 判断元素是否存在，效率极高。因为元素为hash存放
1, {1, b'1', '1', (1,)}
2, {1, (1,), 'a', b'1', '1'}
3, {1, 2, 3, 4, (1,), 'a', b'1', '1'}
4, {1, 2, 3, 4, (1,), 'a', 'r', 's', ' ', b'1', '1', 't'}
5, {2, 3, 4, (1,), 'a', 'r', 's', ' ', b'1', '1', 't'}
6, {2, 3, 4, (1,), 'a', 'r', 's', ' ', b'1', 't'}
2
7, {3, 4, (1,), 'a', 'r', 's', ' ', b'1', 't'}
8, set()

集合的运算

交差并补

6. dict

1
2
3
4
5
6
# 元组有序（可索引），不可变，小括号()表示，可以重复，只读（不能增删改）
## 对比 list：有序（可索引），可变，使用[]表示，元素可重复
### 字符串是不可变的，有序，使用引号（单双，单双三）
#### bytes是不可变的字节序列，bytearray是可变的字节序列
##### set叫集合，元素可变（元素需要可hash）、无序（无法索引,可以迭代）、不重复（去重？？）
###### dict，k-v组合，可变，无序，key不能重复
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
d = {'k':'v','1':2,'aa':[1,2,3],'bb':(32,2)}
print(d)
#访问
print('1,',d['k'])
print('2,',d.get('ss',6))  #6为设置的默认值（可省），k不存在则返回默认值
print('3,',d.setdefault('k',5))  #5为设置的默认值（可省），如果key不存在则添加kv对

print('1，',d)

#添加
d['new'] = 44  #key存在就修改，不存在就添加
print('2，',d)

d.update({'new1':1,"new2":2})  #添加一个对象，只能是字典
d.update(red=1)
d.update((('red1',1),))
print('3，',d)

#删除
d.pop('k')  #key存在就删除并返回value，不存在返回默认值，无默认值报错
d.popitem() #随机删除一个kv对，dict为空则报错
print('4，',d)

#清空
d.clear()
print('5，',d)
{'k': 'v', '1': 2, 'aa': [1, 2, 3], 'bb': (32, 2)}
1, v
2, 6
3, v
1， {'k': 'v', '1': 2, 'aa': [1, 2, 3], 'bb': (32, 2)}
2， {'k': 'v', '1': 2, 'aa': [1, 2, 3], 'bb': (32, 2), 'new': 44}
3， {'k': 'v', '1': 2, 'aa': [1, 2, 3], 'bb': (32, 2), 'new': 44, 'new1': 1, 'new2': 2, 'red': 1, 'red1': 1}
4， {'1': 2, 'aa': [1, 2, 3], 'bb': (32, 2), 'new': 44, 'new1': 1, 'new2': 2, 'red': 1}
5， {}

遍历字典

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
d = {'1': 2, 'aa': [1, 2, 3], 'bb': (32, 2)}
#打印k
for k in d.keys():
    print(k)
print('='*40)
#打印value
for v in d.values():
    print(v)
print('='*40)   
#遍历items
for it in d.items():
    print(it)
print('='*40)     
for k,v in d.items():
    print(k,v)  #接轨
1
aa
bb
========================================
2
[1, 2, 3]
(32, 2)
========================================
('1', 2)
('aa', [1, 2, 3])
('bb', (32, 2))
========================================
1 2
aa [1, 2, 3]
bb (32, 2)

有序字典

1
2
3
4
from collections import OrderedDict
od = OrderedDict()
od['k'] = 'v'
od
OrderedDict([('k', 'v')])

习题1. 用户输入一个数字，打印每一位数字及其重复的次数

1
2
3
4
5
6
str = "11gghhbsdsa"
d = {}
for i in str:
    d[i] = str.count(i)

print(d)
{'1': 2, 'g': 2, 'h': 2, 'b': 1, 's': 2, 'd': 1, 'a': 1}

习题2. 数字重复统计：
1.随机产生100个整数

  1. 数字的范围[-1000,1000]
  2. 降序序输出所有不同的数字及其重复的次数
1
2
3
4
5
6
7
8
import random
lst = random.choices(range(-50,51),k=100)
d = dict(zip(lst,[0]*10))

for k in d.keys():
    d[k] = lst.count(k)

sorted(d.items(),key = lambda x:x[1],reverse=True)
[(20, 6), (-17, 4), (-30, 3), (41, 3), (-19, 2), (-1, 2), (-47, 2), (-9, 1)]
---------------- 谢谢光临 ----------------

本文标题:python基础知识1

文章作者:pxrux

发布时间:2019年04月19日 - 00:04

最后更新:2019年04月19日 - 00:04

原始链接:http://www.mykernel.cn/print-test1.html

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。

0%