Python基础知识入门

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

输入和输出

print()

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

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

print("Hellow world")

Hellow world

print("I am 40 years old.")

I am 40 years old.

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

I am 40 years old

input()

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

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

Please input your name?Bruce

print("My name is", myName)

My name is Bruce

Python的基本数据类型

python中的基本数据类型有：

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

整数和浮点数

python基本运算符

• +， - 加减运算
• * 乘, / 除, // 地板除（floor division）, % 为摸运算（求余）
• ** 指数运算
• = 赋值运算
• == 是否相等判断

(4+8)/2

6.0

(4+9)//4

3

(4+9) % 4

1

1+2+3+4.0+5

15.0

9**0.5

3.0

python数学库

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

0.479425538604203

a = math.pi

布尔型

直接用True、False表示（区分大小写）

4 > 5

False

not (4 > 5)

True

a = 0
a == None

False

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

字符串

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

a = "abcdddcd "
print(a)

abcdddcd

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

abcdefg

hi jklmn

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

print("""dfdfdldl
dfdfdf
dfdfd
dfdfd
""")

   dfdfdldl
   dfdfdf
   dfdfd
   dfdfd

类型的转换

a = int("123")
a

123

b = float(123.21)
b

123.21

c = int(b)
c

123

s = str(b)
s

'123.21'

格式化输入输出

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.5//2

-1.0

分支结构

Python语言风格

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

条件判断

height = 175
weight = 80.5
bmi = weight / height
print(bmi)

0.46

if bmi < 18.5:
    print("过轻")
elif bmi < 25:
    print('正常')
elif bmi < 28:
    print("过重")
elif bim < 32:
    print("肥胖")
else:
    print("严重肥胖")

过轻

循环

for x in ...

sum = 0
for x in range(15):
    sum = sum + x
print(sum)

105

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

• range(stop)

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：跳过当前这次循环，直接开始下一次循环

for i in range(1,100,5):
    if i % 3 == 0:
        break
    print(i)

1

while

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，即可以嵌套

a = [1,2,3,4,5]
len(a)

5

a[-1]

5

a.append(6)
a

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

a.insert(0, 0)
a

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

get = a.pop()
get

6

c = [[1,2,3],[4,5,6]]
c[0][2]

3

元组tuple

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

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

b=1,2,3
b

(1, 2, 3)

a,b=1,2
a

1

c=[1,]
c

[1]

a,b=b,a
a

2

序列运算

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

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

(1,2,3) + (4,5,6)

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

[1,2] * 5

[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]

切片(SLICE)

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

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

['Michael', 'Sarah', 'Tracy']

names[:4]

['Michael', 'Sarah', 'Tracy', 'Rose']

names[2:]

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

names[0:5:2]

['Michael', 'Tracy', 'Tina']

names[-2:]

['Rose', 'Tina']

names[-2:-5:-1]

['Rose', 'Tracy', 'Sarah']

m1 = names[:]
m1

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

m2 = names
m2[0] = 'bruce'
m2

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

names

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

m1

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

字典

使用键-值（key-value）存储，无序

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

85

d['Adam'] = 67
d

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

d['Bob'] = 80
d.get("Bruce", -1)

-1

• 一个key值只能对应一个value，多次对一个key放入value，后面的值会冲掉前面的
• 如果key不存在，dict会出错。建议通过get()方法获取，如果key不存在可以返回None或指定值。
• 要删除一个key，用pop(key)方法删除，对应的value也会从dict中删除。

d.pop('Adam')
d

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

d = {'a':1,'b':2,'c':3}
d.items()

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

d.values()
d.keys()

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

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

a 1 b 2 c 3

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

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]}

d3 = {'a':{'AA':100}, 'b':{'DD':1000}}
d3

{'a': {'AA': 100}, 'b': {'DD': 1000}}

d3['a']

{'AA': 100}

d3['a']['AA']

100

集合Set

• 可理解为无key的字典。元素不允许重复。
• 支出数学集合运算：交集、并集、差等。

{1,2,3,2,1}

{1, 2, 3}

setA = {1,2,3}
setB = {3,4,5}
setA|setB

{1, 2, 3, 4, 5}

setA.union(setB)

{1, 2, 3, 4, 5}

setA.intersection(setB)

{3}

setA - setB

{1, 2}

setA.issubset(setB)

False

字符串

s = "abcdefgg"
s[-1] 

'g'

s[2:5]

'cde'

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()
• 字符串也是可迭代对象

a = [1, 2, 3, 4, 5]
for i in a:
    print(i)

1 2 3 4 5

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

a b c

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

1 2 3

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

a 1 b 2 c 3

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

I

l o v e

y o u !

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

0 1 1 2 2 3 3 4 4 5

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

0 1 1 2 2 3 3 4 4 5

数据结构之间的转换

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

[1, 3, 5]

set([1,2,3,2,1])

{1, 2, 3}

dict([('a',1),('b',3),('c',5)])

{'a': 1, 'b': 3, 'c': 5}

range(1,11)

range(1, 11)

tuple(range(11))

(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

list(range(1,11))

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

tuple('abcdefg')

('a', 'b', 'c', 'd', 'e', 'f', 'g')

列表生成式()

简单却强大的用来创建list

g = [x**2 for x in range(10)]
g

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

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循环来迭代。

g = (x**2 for x in range(10))
g

<generator object <genexpr> at 0x000001D584667C48>

next(g)

0

next(g)

1

for n in g:
    print(n)

4 9 16 25 36 49 64 81

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

• 如果一个函数中包含yield关键字，则该函数就不再是一个普通函数，而是一个generator

def fib(max):
    n,a,b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a+b
        n = n + 1

fib(5)

1 1 2 3 5

def fib2(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a+b
        n = n + 1
        
    return 'done'

fib2(5)

<generator object fib2 at 0x000001D584629248>

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类型，它们表示一个惰性计算的序列

c = [0, 1,2,3,4,5]

ita = iter(c)
ita

<list_iterator at 0x1d584632788>

next(ita)

0

Python常用高阶函数

Python函数

内置函数

• abs(),max()
• 数据类型转换函数,int(),float(),str()

abs(-20)

20

max(1, 3)

3

int('123')

123

str("1.23")

'1.23'

bool(1)

True

自定义函数

• 定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号，然后在缩进块中编写函数体
• 函数的返回值用return语句返回
• 如果没有return语句，函数执行完后也会返回结果，只是结果为None
• 函数可以返回多个值，用tuple表示。如果返回结果为列表，但列表只有一个元素，不要忘记后面要带一个逗号

import math
def move(x, y, step, angle = 0):
    nx = x + step * math.cos(angle)
    ny = y + step * math.sin(angle)
    
    return nx, ny

move(2, 2, 3)

(5.0, 2.0)

move(2, 2, 3, math.pi / 2)

(2.0, 5.0)

map函数

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

• 第一个参数func， 是函数名；第二个参数是可迭代对象iterable
• 根据提供的函数对指定序列做映射，将函数依次作用到可迭代对象中的每一个元素，并把结果作为新的Iterator返回。

c = [0, 1,2,3,4,5]

def myFunc(x):
    return x**2 + 1

map(myFunc, c)

<map at 0x1d58464ee08>

list(map(myFunc, c))

[1, 2, 5, 10, 17, 26]

def f(x, y):
    return (x, y)

list1 = [0, 1, 2, 3, 4, 5, 6]
list2 = ['Sun', 'Mon', 'Tue', 'Wen', 'Thur', 'Fri', 'Stat']
map(f, list1, list2)

<map at 0x1d584680d88>

dict(map(f, list1, list2))

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

zip函数

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

• 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同
• 利用 * 号操作符，可以将元组解压为列表。

a = [1,2,3,4]
b = [5,6,7,8]
zip(a,b)

<zip at 0x1d5846467c8>

zipped = tuple(zip(a,b))
zipped

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

list(zip(list1,list2))

[(0, 'Sun'),
   (1, 'Mon'),
   (2, 'Tue'),
   (3, 'Wen'),
   (4, 'Thur'),
   (5, 'Fri'),
   (6, 'Stat')]

dict(zip(list2, list1))

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

x,y=zip(*zipped)
x
y

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

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

True

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

dict(zip(names, score))

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

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

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

lambda匿名函数

def square(x):
    return x**2 + 1

tuple(map(square, [1,2,3,4,5]))

(2, 5, 10, 17, 26)

a

[1, 2, 3, 4]

list(map(lambda x:x**2 + 1, a) )

[2, 5, 10, 17]

filter函数

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

filter(lambda x: x %2 ==0, a)

<filter at 0x1d584692a88>

def isOdd(x):
    return x % 2 == 0

tuple(filter(isOdd, a))

(2, 4)

list(filter(lambda x: x %2 ==0, a))

[2, 4]

排序函数

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

• sort函数会修改列表本身，即原位排序
• sorted产生一个新的列表，原列表保持不变。

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

c.sort()
c

[1, 2, 3, 4, 5]

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

e = sorted(d)

e

[1, 2, 3, 4, 5]

sorted(d, reverse=True)

[5, 4, 3, 2, 1]