python初学篇笔记_Python学习笔记（基础篇）

Python 基础

输入输出

输出

使用print()可以向屏幕上输出指定的文字：

>>> print('Hello world!')

Hello world!

print()中可以接受多个字符串，当用逗号隔开时会形成一连串的输出,逗号相当于空格：

>>> print('I','LOVE','Python')

I LOVE Python

print()也可以用于计算：

>>> print(100+100)

200

>>> print('100 + 100 =',100+100)

100 + 100 = 200

输入

input()可以让用户输入字符：

>>> aa=input()

Python

>>> aa

'Python'

还可以添加提示：

>>> name=input("请输入你的名字：\n")

请输入你的名字：

andy

>>> name

'andy'

>>> print('hello',name)

hello andy

字符串编码

ASCII:使用一个字节，此编码包含大小写英文字母，数字符号等。

Unicode：一般使用两个字节表示字符，可表示所有语言字符。

在使用Unicode表示ASCII字符的时候，只需要在二进制的ASCII码前补0即可。

UTF-8：可变长编码。将一个Unicode字符根据不同的数字大小转化成1-6个字节，通常英文被转化为1个字节，汉字通常是3个字节。

在保存和传输文件时为了节省空间都会转化为UTF-8的字符编码格式，当需要在内存中加载时再转化为Unicode编码。

转化函数

可以使用ord()和chr()函数对字符和编码进行转换：

>>> ord('A')

65

>>> ord('中')

20013

>>> chr(66)

'B'

>>> chr(25991)

'文'

也可以使用16进制的表示：

>>> '\u4e2d\u6587'

'中文'

str类型和bytes类型数据转换

由于Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str转变为以字节为单位的bytes，Python 对字节类型的表示使用b表示，如要表示一个byte类型的数据，使用加b的前缀，用单引号或者双引号：

x=b'ABC'

存储或传输数据的时候，可以使用ASCII和UTF-8的编码方式将str类型的数据装换为byte类型，使用encode()方法(英文使用ascii的编码方式，中文要使用utf-8的编码方式)：

>>> 'abc'.encode('ascii')

b'abc'

>>> '中国'.encode('utf-8')

b'\xe4\xb8\xad\xe5\x9b\xbd'

反过来，如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode()方法：

>>> b'abc'.decode('ASCII')

'abc'

>>> b'\xe4\xb8\xad\xe5\x9b\xbd'.decode('utf-8')

'中国'

数据长度计算

要计算str包含多少个字符，可以用len()函数：

>>> len('ABC')

3

>>> len('中国')

2

len()函数计算的是str的字符数，如果换成bytes，len()函数就计算字节数：

>>> len(b'ABC')

3

>>> len(b'\xe4\xb8\xad\xe5\x9b\xbd')

6

>>> len('中国'.encode('utf-8'))

6

可见，1个中文字符经过UTF-8编码后通常会占用3个字节，而1个英文字符只占用1个字节。

当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：

#!/usr/bin/env python3

# -*- coding: utf-8 -*-

格式化输出

对于一些格式化的要求，一般使用%#的方式来表示不同的变量，在之后使用%(数值)来表示具体的数值：

>>> '你好，%s' %'Andy'

'你好，Andy'

多个不同类型的变量：

>>> 'hi %s,you age is %d' % ('Andy',24)

'hi Andy,you age is 24'

常用的占位符表示：

%d

整数

%f

浮点数

%s

字符串

%x

十六进制整数

其中，格式化整数和浮点数还可以指定是否补0和整数与小数的位数：

>>> '%2d-%02d' % (3, 1)

' 3-01'

>>> '%.2f' % 3.1415926

'3.14

如果你不太确定应该用什么，%s永远起作用，它会把任何数据类型转换为字符串：

>>> 'Age: %s. Gender: %s' % (25, True)

'Age: 25. Gender: True'

当字符串里面的%是一个普通字符时，就需要转义，用%%来表示一个%：

>>> 'growth rate: %d %%' % 7

'growth rate: 7 %'

list和tuple

list

list是一种有序的集合，可以随时添加和删除其中的元素。

>>> a = ['a', 'b', 'c']

>>> a

['a', 'b', 'c']

用len()函数可以获得list元素的个数：

>>> len(a)

3

用索引来访问list中每一个位置的元素，记得索引是从0开始的：

>>> a [0]

'a'

>>> a [2]

'c'

如果要取最后一个元素，除了计算索引位置外，还可以使用倒序的方式，用负数表示，最后一个为-1，直接获取最后一个元素：

>>> a[-1]

'c'

>>> a[-2]

'b'

list是一个可变的有序表，所以，可以往list中追加元素到末尾，使用append()函数：

>>> a.append('x')

>>> a

['a', 'b', 'c', 'x']

指定索引位置插入,使用insert(,)函数：

>>> a.insert(1,'y')

>>> a

['a', 'y', 'b', 'c', 'x']

删除list末尾的元素，用pop()方法：

>>> a.pop()

'x'

>>> a

['a', 'y', 'b', 'c']

删除指定位置的元素，用pop(i)方法，其中i是索引位置：

>>> a.pop(1)

'y'

>>> a

['a', 'b', 'c']

要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：

>>> a[1]='hello'

>>> a

['a', 'hello', 'c']

list里面的元素的数据类型也可以不同，比如：

>>> L = ['Apple', 123, True]

list中还可以嵌套其他list,且可以是变量：

>>> s = ['python', 'java', ['asp', 'php'], 'scheme']

>>> p = ['asp', 'php']

>>> s = ['python', 'java', p, 'scheme']

要拿到'php'可以写p[1]或者s[2][1]，因此s可以看成是一个二维数组，类似的还有三维、四维……数组，不过很少用到。

如果一个list中一个元素也没有，就是一个空的list，它的长度为0：

>>> L = []

>>> len(L)

0

tuple

另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改，它没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用b[0]，b[-1]，但不能赋值成另外的元素。

>>> b = ('a','b','c')

>>> b[1]

'b'

>>> b.append('x')

Traceback (most recent call last):

File "", line 1, in

AttributeError: 'tuple' object has no attribute 'append'

不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。

tuple的陷阱：当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来，比如：

>>> t = (1, 2)

>>> t

(1, 2)

如果要定义一个空的tuple，可以写成()：

>>> t = ()

>>> t

()

只有1个元素的tuple定义时必须加一个逗号,，来消除歧义,如果不加逗号，相当于赋值运算：

>>> t = (1,)

>>> t

(1,)

在tuple中定义list,那么tuple中的list部分就是可变的：

>>> t = ('a', 'b', ['A', 'B'])

>>> t[2][0] = 'X'

>>> t[2][1] = 'Y'

>>> t

('a', 'b', ['X', 'Y'])

条件语句

if ... else 条件判断：

if :

elif :

elif :

else:

示例(缩进敏感，默认使用4个空格)：

age = 3

if age >= 18:

print('adult')

elif age >= 6:

print('teenager')

else:

print('kid')

if语句执行有个特点，它是从上往下判断，如果在某个判断上是True，把该判断对应的语句执行后，就忽略掉剩下的elif和else：

age = 20

if age >= 6:

print('teenager')

elif age >= 18:

print('adult')

else:

print('kid')

if判断条件还可以简写(x只要为非空的数值、字符串、list等，就判断为True,否则为False):

if x:

print('True')

循环语句

for 循环：

sum = 0

for x in range(101):

sum = sum + x

print(sum)

rang()函数可以生成一个序列，使用list()可以转换为list:

>>> list(range(5))

[0, 1, 2, 3, 4]

while循环：

sum = 0

n = 99

while n > 0:

sum = sum + n

n = n - 2

print(sum)

break 用来结束循环

continue 跳过当前的循环，继续下一次循环

break语句可以在循环过程中直接退出循环，而continue语句可以提前结束本轮循环，并直接开始下一轮循环。这两个语句通常都必须配合if语句使用。不要滥用break和continue语句。break和continue会造成代码执行逻辑分叉过多，容易出错。大多数循环并不需要用到break和continue语句，上面的两个例子，都可以通过改写循环条件或者修改循环逻辑，去掉break和continue语句。

dict和set

Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值(key-value)存储，具有极快的查找速度。

>>> aa={'a':1,'b':2,'c':3}

>>> aa['b']

2

把数据放入dict的方法，除了初始化时指定外，还可以通过key放入。由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉：

>>> aa['a']=100

>>> aa['a']

100

如果key不存在，dict就会报错：

>>> aa['d']

Traceback (most recent call last):

File "", line 1, in

KeyError: 'd'

可以通过如下两种方法判断KEY值是否存在：

使用in判断key值是否存在：

>>> 'd' in aa

False

>>> 'a' in aa

True

通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value：

>>> aa.get('c','xx')

3

>>> aa.get('d','xx')

'xx'

>>> aa.get('d')

>>>

要删除一个key，用pop(key)方法，对应的value也会从dict中删除：

>>> aa.pop('c')

3

>>> aa.get('c')

>>>

>>> aa

{'a': 100, 'b': 2}

注意： dict内部存放的顺序和key放入的顺序是没有关系的。

和list比较，dict有以下几个特点：

查找和插入的速度极快，不会随着key的增加而变慢；

需要占用大量的内存，内存浪费多。

list有与之相反的特性：

查找和插入的时间随着元素的增加而增加；

占用空间小，浪费内存很少。

提示：dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法(Hash)。

要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key.

set

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，而且元素是无序的，所以，在set中，没有重复的key。

要创建一个set，需要提供一个list作为输入集合：

>>> s = set([1, 2, 3])

>>> s

{1, 2, 3}

重复元素在set中自动被过滤：

>>> s = set([1, 1, 2, 2, 3, 3])

>>> s

{1, 2, 3}

通过remove(key)方法可以删除元素：

>>> s.remove(4)

>>> s

{1, 2, 3}

set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：

>>> s1 = set([1, 2, 3])

>>> s2 = set([2, 3, 4])

>>> s1 & s2

{2, 3}

>>> s1 | s2

{1, 2, 3, 4}

set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。

>>> a

{8, 9, 10}

>>> a.add(list)

Traceback (most recent call last):

File "", line 1, in

TypeError: unhashable type: 'list'