Bruce Han的博客

不积跬步,无以至千里;不积小流,无以成江海。

0%

Python基础知识入门

本文主要简单介绍Python的入门基础知识,包括简单的输入输出、数据类型、循环结构 以及Python的特殊数据结构:列表、元组以及字典等。

输入和输出

print()

Python中基本输出函数是print()函数,

  • 用print(),在括号中加上字符串就可以向屏幕输出指定的文字
  • 可以接受多个字符串,用逗号“,”隔开,就可以连成一串输出。
1
print("Hellow world")

Hellow world

1
print("I am 40 years old.")

I am 40 years old.

1
print("I am", "40 years old")

I am 40 years old

input()

接受用户输入,并保存在一个变量中

1
myName = input("Please input your name?")

Please input your name?Bruce

1
print("My name is", myName)

My name is Bruce

Python的基本数据类型

python中的基本数据类型有:

  1. 整数
  2. 浮点数
  3. 布尔型
  4. 空值
  5. 字符串

整数和浮点数

python基本运算符

  • +, - 加减运算
  • * 乘, / 除, // 地板除(floor division), % 为摸运算(求余)
  • ** 指数运算
  • = 赋值运算
  • == 是否相等判断
1
(4+8)/2

6.0

1
(4+9)//4

3

1
(4+9) % 4

1

1
1+2+3+4.0+5

15.0

1
9**0.5

3.0

python数学库

1
2
3
# 导入数学库
import math
math.sin(0.5)

0.479425538604203

1
a = math.pi

布尔型

直接用TrueFalse表示(区分大小写)

1
4 > 5

False

1
not (4 > 5)

True

1
2
a = 0
a == None

False

None是Python中的一个空值,不能理解为0.

字符串

用单引号、双引号、三引号扩起来的一段文本。

1
2
a = "abcdddcd "
print(a)

abcdddcd

1
print("abcdefg\nhi\tjklmn\\")

abcdefg

hi jklmn

转义字符:\n表示换行,\t表示制表符,\\表示字符。 三引号引起的文本字符串可以换行。

1
2
3
4
5
print("""dfdfdldl
dfdfdf
dfdfd
dfdfd
""")
   dfdfdldl
   dfdfdf
   dfdfd
   dfdfd

类型的转换

1
2
a = int("123")
a

123

1
2
b = float(123.21)
b

123.21

1
2
c = int(b)
c

123

1
2
s = str(b)
s

'123.21'

格式化输入输出

1
print("I am %s, I am %d years old. I weights %6.2f pounds." % ('Bruce Han', 40, 88.8))

I am Bruce Han, I am 40 years old. I weights 88.80 pounds.

1
-1.5//2
-1.0

分支结构

Python语言风格

  • 程序块使用4个空格缩进(确保不混用Tab和空格)
  • # 开头的语句是注释
  • Python语言区分大小写
  • 变量名必须是大小写英文、数字和下划线的组合,且不能用数字开头
  • 等号(=)是赋值,可以把任意数据类型赋值给变量,
  • 同一变量可以反复赋值,而且可以是不同类型的变量(变量本身类型不固定的语言称之为动态语言,与之相对应的是静态语言
  • 通常用全部大写的变量名表示常量(用全部大写的变量名只是一个习惯用法,并不能保证其不变)

条件判断

1
2
3
4
height = 175
weight = 80.5
bmi = weight / height
print(bmi)
0.46
1
2
3
4
5
6
7
8
9
10
if bmi < 18.5:
print("过轻")
elif bmi < 25:
print('正常')
elif bmi < 28:
print("过重")
elif bim < 32:
print("肥胖")
else:
print("严重肥胖")
过轻

循环

for x in ...

1
2
3
4
sum = 0
for x in range(15):
sum = sum + x
print(sum)
105

range函数: - range(start, stop[,step]

  • range(stop)
1
2
3
4
for i in range(1,100,5):
if i % 3 == 0:
continue
print(i)

1 11 16 26 31 41 46 56 61 71 76 86 91

跳出循环:

  • break:提前退出循环
  • continue:跳过当前这次循环,直接开始下一次循环
1
2
3
4
for i in range(1,100,5):
if i % 3 == 0:
break
print(i)
1

while

1
2
3
4
5
6
7
sum = 0
x = 0
while x < 15:
sum += x
x += 1

print("The sum from 0 to 14 is", sum)

The sum from 0 to 14 is 105

Python数据结构和序列

特殊的数据结构

  1. 列表(list):[ ]
  2. 元组(tuple):( )
  3. 字典(dictionary):{ }
  4. 集合(set):{ }

list:是一种有序的数据容器

  • 可以随时添加和删除其中的元素
  • len(a)函数可以获取list a中的元素个数
  • 用索引来访问每一个位置的元素,索引是从0开始,最后一个元素的索引是len(a)-1
  • 如果要取最后一个元素,除了计算索引位置外,还可以用-1做索引,直接获取最后一个元素
  • append追加元素;insert指定位置插入;pop去处一个元素
  • list里面的元素数据类型可以相同,也可以不同;list的元素可以为list,即可以嵌套
1
2
a = [1,2,3,4,5]
len(a)

5

1
a[-1]

5

1
2
a.append(6)
a

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

1
2
a.insert(0, 0)
a
[0, 1, 2, 3, 4, 5, 6]
1
2
get = a.pop()
get
6
1
2
c = [[1,2,3],[4,5,6]]
c[0][2]
3

元组tuple

一种有序列表、定长、不可变

  • len()函数可以获得tuple元素各数
  • 可以用索引访问tuple中的每一个元素,索引从0开始,最后一个元素索引是len(a)-1
  • 最后一个元素可以用索引-1获取
  • tuple一旦初始化后不能修改
  • tuple陷井
    • 在定义的时候,tuple的元素就必须确定下来
    • 只有一个元素的tuple定义时必须加一个逗号来消除歧义
    • 多个值赋值给一个变量,
1
2
b=1,2,3
b
(1, 2, 3)
1
2
a,b=1,2
a
1
1
2
c=[1,]
c

[1]

1
2
a,b=b,a
a
2

序列运算

+ :进行序列连接运算,生成新的序列

* :生成新的序列,原来的序列被重复x次

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

切片(SLICE)

获取一个list或tuple的部分元素。结束索引的元素不包括在内

1
2
names = ['Michael', 'Sarah', 'Tracy', 'Rose', 'Tina']
names[0:3]
['Michael', 'Sarah', 'Tracy']
1
names[:4]
['Michael', 'Sarah', 'Tracy', 'Rose']
1
names[2:]

['Tracy', 'Rose', 'Tina']

1
names[0:5:2]
['Michael', 'Tracy', 'Tina']
1
names[-2:]
['Rose', 'Tina']
1
names[-2:-5:-1]
['Rose', 'Tracy', 'Sarah']
1
2
m1 = names[:]
m1
['Michael', 'Sarah', 'Tracy', 'Rose', 'Tina']
1
2
3
m2 = names
m2[0] = 'bruce'
m2

['bruce', 'Sarah', 'Tracy', 'Rose', 'Tina']

1
names
['bruce', 'Sarah', 'Tracy', 'Rose', 'Tina']
1
m1
['Michael', 'Sarah', 'Tracy', 'Rose', 'Tina']

字典

使用键-值(key-value)存储,无序

1
2
d={"Michael":85, "Bob":75, "Tracy":90}
d['Michael']
85
1
2
d['Adam'] = 67
d

{'Michael': 85, 'Bob': 75, 'Tracy': 90, 'Adam': 67}

1
2
d['Bob'] = 80
d.get("Bruce", -1)
-1
  • 一个key值只能对应一个value,多次对一个key放入value,后面的值会冲掉前面的
  • 如果key不存在,dict会出错。建议通过get()方法获取,如果key不存在可以返回None或指定值。
  • 要删除一个key,用pop(key)方法删除,对应的value也会从dict中删除。
1
2
d.pop('Adam')
d

67 {'Michael': 85, 'Bob': 80, 'Tracy': 90}

1
2
d = {'a':1,'b':2,'c':3}
d.items()
dict_items([('a', 1), ('b', 2), ('c', 3)])
1
2
d.values()
d.keys()

dict_values([1, 2, 3]) dict_keys(['a', 'b', 'c'])

1
2
for (k, v) in d.items():
print(k, v)

a 1 b 2 c 3

字典可以嵌套,即字典的value可以是字典。

1
2
d2 = {'a':[1,2,3,4,5,6],'b':[6,7,8,9]}
d2
{'a': [1, 2, 3, 4, 5, 6], 'b': [6, 7, 8, 9]}
1
2
d3 = {'a':{'AA':100}, 'b':{'DD':1000}}
d3
{'a': {'AA': 100}, 'b': {'DD': 1000}}
1
d3['a']

{'AA': 100}

1
d3['a']['AA']
100

集合Set

  • 可理解为无key的字典。元素不允许重复。
  • 支出数学集合运算:交集、并集、差等。
1
{1,2,3,2,1}
{1, 2, 3}
1
2
3
setA = {1,2,3}
setB = {3,4,5}
setA|setB
{1, 2, 3, 4, 5}
1
setA.union(setB)

{1, 2, 3, 4, 5}

1
setA.intersection(setB)
{3}
1
setA - setB
{1, 2}
1
setA.issubset(setB)
False

字符串

1
2
s = "abcdefgg"
s[-1]
'g'
1
s[2:5]
'cde'
1
2
s= '123'
int(s)

123

迭代(Iteration)

列表、元组、字典、字符串元素的遍历

  • 如果给定一个list或tuple,我们可以通过for循环来遍历这个list或tuple,这种遍历我们称为迭代(Iteration)
  • 默认情况下,dict迭代的是key。如果要迭代value,可以用for value in d.values(),如果要同时迭代key和value,可以用for k, v in d.items()
  • 字符串也是可迭代对象
1
2
3
a = [1, 2, 3, 4, 5]
for i in a:
print(i)

1 2 3 4 5

1
2
3
d = {'a':1, 'b':2, 'c':3}
for key in d:
print(key)

a b c

1
2
for v in d.values():
print(v)

1 2 3

1
2
for k, v in d.items():
print(k, v)

a 1 b 2 c 3

1
2
3
s='I love you!'
for ch in s:
print(ch)

I

l o v e

y o u !

1
2
for i in range(len(a)):
print(i, a[i])

0 1 1 2 2 3 3 4 4 5

1
2
for i, v in enumerate(a):
print(i, v)

0 1 1 2 2 3 3 4 4 5

数据结构之间的转换

1
2
d =(1,3,5)
list(d)

[1, 3, 5]

1
set([1,2,3,2,1])
{1, 2, 3}
1
dict([('a',1),('b',3),('c',5)])
{'a': 1, 'b': 3, 'c': 5}
1
range(1,11)
range(1, 11)
1
tuple(range(11))
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
1
list(range(1,11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
1
tuple('abcdefg')
('a', 'b', 'c', 'd', 'e', 'f', 'g')

列表生成式()

简单却强大的用来创建list

1
2
g = [x**2 for x in range(10)]
g
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
1
2
odd = [x**2 for x in range(10) if x % 2 == 0]
odd

[0, 4, 16, 36, 64]

Python生成器(generator)

一边循环一边计算的机制

  • 把一个列表生成式中的[]g改为(),就创建了一个generator
  • 可以通过next函数获得generator的下一个返回值
  • 基本上从来不会用next()来获取下一个返回值,而是直接使用for循环来迭代。
1
2
g = (x**2 for x in range(10))
g
<generator object <genexpr> at 0x000001D584667C48>
1
next(g)
0
1
next(g)
1
1
2
for n in g:
print(n)

4 9 16 25 36 49 64 81

如果推算的算法比较复杂,用类似列表生成式的for循环无法实现时可以用函数实现。

  • 如果一个函数中包含yield关键字,则该函数就不再是一个普通函数,而是一个generator
1
2
3
4
5
6
def fib(max):
n,a,b = 0, 0, 1
while n < max:
print(b)
a, b = b, a+b
n = n + 1
1
fib(5)

1 1 2 3 5

1
2
3
4
5
6
7
8
def fib2(max):
n, a, b = 0, 0, 1
while n < max:
yield b
a, b = b, a+b
n = n + 1

return 'done'
1
fib2(5)
<generator object fib2 at 0x000001D584629248>
1
2
for u in fib2(5):
print(u)

1 1 2 3 5

迭代器(Iterator)和可迭代对象(Iterable)

直接用for循环的数据类型有:

  1. 集合数据类型:list,tuple,dict,set,str
  2. generator,包括生成器和带yield的generator function
  • 可以直接作用于for循环的对象通称为可迭代对象(Iterable)
  • 生成器都是Iterator对象,但list、dict、str虽然是Iterable,但不是Iterator
  • 可以通过函数iter()把list、dict、str等Iterable变成Iterator

小结:

  • 凡是可作用于for循环的对象都是Iterable
  • 凡是可作用于next函数的对象都是Iterator类型,它们表示一个惰性计算的序列
1
c = [0, 1,2,3,4,5]
1
2
ita = iter(c)
ita
<list_iterator at 0x1d584632788>
1
next(ita)

0

Python常用高阶函数

Python函数

内置函数

  • abs(),max()
  • 数据类型转换函数,int(),float(),str()
1
abs(-20)
20
1
max(1, 3)
3
1
int('123')
123
1
str("1.23")
'1.23'
1
bool(1)

True

自定义函数

  • 定义一个函数要使用def语句,依次写出函数名、括号、括号中的参数和冒号,然后在缩进块中编写函数体
  • 函数的返回值用return语句返回
  • 如果没有return语句,函数执行完后也会返回结果,只是结果为None
  • 函数可以返回多个值,用tuple表示。如果返回结果为列表,但列表只有一个元素,不要忘记后面要带一个逗号
1
2
3
4
5
6
import math
def move(x, y, step, angle = 0):
nx = x + step * math.cos(angle)
ny = y + step * math.sin(angle)

return nx, ny
1
move(2, 2, 3)
(5.0, 2.0)
1
move(2, 2, 3, math.pi / 2)
(2.0, 5.0)

map函数

map(func, iterable,...)函数:

  • 第一个参数func, 是函数名;第二个参数是可迭代对象iterable
  • 根据提供的函数对指定序列做映射,将函数依次作用到可迭代对象中的每一个元素,并把结果作为新的Iterator返回。
1
c = [0, 1,2,3,4,5]
1
2
def myFunc(x):
return x**2 + 1
1
map(myFunc, c)
<map at 0x1d58464ee08>
1
list(map(myFunc, c))
[1, 2, 5, 10, 17, 26]
1
2
def f(x, y):
return (x, y)
1
2
3
list1 = [0, 1, 2, 3, 4, 5, 6]
list2 = ['Sun', 'Mon', 'Tue', 'Wen', 'Thur', 'Fri', 'Stat']
map(f, list1, list2)

<map at 0x1d584680d88>

1
dict(map(f, list1, list2))

{0: 'Sun', 1: 'Mon', 2: 'Tue', 3: 'Wen', 4: 'Thur', 5: 'Fri', 6: 'Stat'}

zip函数

zip(iterable, ...)函数:将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的迭代器。

  • 如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同
  • 利用 * 号操作符,可以将元组解压为列表。
1
2
3
a = [1,2,3,4]
b = [5,6,7,8]
zip(a,b)

<zip at 0x1d5846467c8>

1
2
zipped = tuple(zip(a,b))
zipped
((1, 5), (2, 6), (3, 7), (4, 8))
1
list(zip(list1,list2))
[(0, 'Sun'),
   (1, 'Mon'),
   (2, 'Tue'),
   (3, 'Wen'),
   (4, 'Thur'),
   (5, 'Fri'),
   (6, 'Stat')]
1
dict(zip(list2, list1))
{'Sun': 0, 'Mon': 1, 'Tue': 2, 'Wen': 3, 'Thur': 4, 'Fri': 5, 'Stat': 6}
1
2
3
x,y=zip(*zipped)
x
y

(1, 2, 3, 4) (5, 6, 7, 8)

1
list(x) == a and list(y) == b

True

1
2
names = ('A','B','C','D')
score = (1,2,3,4)
1
dict(zip(names, score))

{'A': 1, 'B': 2, 'C': 3, 'D': 4}

1
dict(tuple(zip(names,score)))

{'A': 1, 'B': 2, 'C': 3, 'D': 4}

lambda匿名函数

1
2
def square(x):
return x**2 + 1
1
tuple(map(square, [1,2,3,4,5]))

(2, 5, 10, 17, 26)

1
a
[1, 2, 3, 4]
1
list(map(lambda x:x**2 + 1, a) )
[2, 5, 10, 17]

filter函数

filter(func, iterable)用于过滤序列。接收一个函数和一个序列,把传入的函数依次作用于每个元素,然后根据返回值是True还是False决定保留还是丢弃该 元素。filter()函数返回的是一个Iterator。

1
filter(lambda x: x %2 ==0, a)
<filter at 0x1d584692a88>
1
2
def isOdd(x):
return x % 2 == 0
1
tuple(filter(isOdd, a))
(2, 4)
1
list(filter(lambda x: x %2 ==0, a))
[2, 4]

排序函数

列表的sort()函数和sorted(iterable)函数

  • sort函数会修改列表本身,即原位排序
  • sorted产生一个新的列表,原列表保持不变。
1
c = [2,3,5,4,1]
1
2
c.sort()
c

[1, 2, 3, 4, 5]

1
d = [2,3,5,4,1]
1
e = sorted(d)
1
e
[1, 2, 3, 4, 5]
1
sorted(d, reverse=True)
[5, 4, 3, 2, 1]