1.解释器
编译器或者解释器就是负责把符合语法的程序代码转换成CPU能够执行的机器码,然后执行。Python也不例外。同时Python解释器承担了内存管理的复杂任务,这大大简化了应用程序的编写。
Python的解释器有很多,有CPython,IPython,PyPy,Jython,IronPython等。其中 CPython是使用最广的Python解释器。教程的所有代码也都在CPython下执行。( CPython用>>>作为提示符,而IPython用In [序号]:作为提示符。)
2.语法特点
以#开头的语句是注释,注释是给人看的,可以是任意内容,解释器会忽略掉注释。其他每一行都是一个语句,当语句以冒号:结尾时,缩进的语句视为代码块。
Python程序是大小写敏感的,如果写错了大小写,程序会报错。
3. 数据类型
python能够直接处理的数据类型有:
3.1 整数(包括负整数):
数学方法表示:1,100,-8080,0,等等。
用十六进制表示: 十六进制用0x前缀和0-9,a-f表示,例如:0xff00,0xa5b4c3d2,等等。
3.2 浮点数(小数):
数学方法表示: 如1.23,3.14,-9.01,等等。用科学计数法表示(很大/很小的浮点数): 把10用e替代,1.23x109就是1.23e9,或者12.3e8,0.000012可以写成1.2e-5,等等。注: 整数和浮点数在计算机内部存储的方式是不同的,整数运算永远是精确的(除法难道也是精确的?是的!),而浮点数运算则可能会有四舍五入的误差。
3.3 字符串:
字符串是以单引号'或双引号"括起来的任意文本,需要注意的是 ''或""本身只是一种表示方式,不是字符串的一部分。
(1):如果'本身也是一个字符,那就可以用""括起来
(2):如果字符串内部既包含'又包含"则可以用转义字符\来标识。比如 'I\'m \"OK\"!'
(3):转义字符\可以转义很多字符,比如\n表示换行,\t表示制表符,字符\本身也要转义,所以\\表示的字符就是\。
(4):如果字符串里面有很多字符都需要转义,就需要加很多\,为了简化,Python还允许用r''表示''内部的字符串默认不转义。比如
>>> print(r'\\\t\\')\\\t\\
(5):字符串内部有很多换行,用\n写在一行里不好阅读,为了简化,Python允许用'''...'''的格式表示多行内容。比如
>>> print('''line1... line2... line3''')line1line2line3
(6):字符编码: 字符串比较特殊的是还有一个编码问题
历史:
最早计算机采用8bit作为一个字节(byte),所以一个字节能表示的最大的整数是255(二进制11111111=十进制255),如果要表示更大的整数,就必须用更多的字节。比如两个字节可以表示的最大整数是65535,4个字节可以表示的最大整数是4294967295。
最早出现的是ASCII编码,只有127个字符被编码到计算机里,也就是大小写英文字母、数字和一些符号。可是这个要处理中文的话,就需要两个字节,而且还不能和ASCII码冲突。
中国制定了GB2312编码,用来把中文编进去。日本把日文编到Shift_JIS里,韩国把韩文编到Euc-kr里,各国有各国的标准,就会不可避免地出现冲突,结果就是,在多语言混合的文本中,显示出来会有乱码。
之后出现了Unicode把所有语言都统一到一套编码里,这样就不会再有乱码问题了。但是,如果你写的文本基本上全部是英文的话,用Unicode编码比ASCII编码需要多一倍的存储空间,在存储和传输上就十分不划算。
所以又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节,常用的英文字母被编码成1个字节,汉字通常是3个字节,只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符,用UTF-8编码就能节省空间:
计算机内存中的运用:
在计算机内存中,统一使用Unicode编码,当需要保存到硬盘或者需要传输的时候,就转换为UTF-8编码。
用记事本编辑的时候,从文件读取的UTF-8字符被转换为Unicode字符到内存里,编辑完成后,保存的时候再把Unicode转换为UTF-8保存到文件.
浏览网页的时候,服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器:所以你看到很多网页的源码上会有类似的信息,表示该网页正是用的UTF-8编码。
python中字符串编码:
在最新的Python 3版本中,字符串是以Unicode编码的,也就是说,Python的字符串支持多语言
单个字符的编码:
ord()函数获取字符的整数表示chr()函数把编码转换为对应的字符
str和byte的互相转换:
(为了避免乱码问题,应当始终坚持使用UTF-8编码对str和bytes进行转换。):
str-> bytes (encode方法):
如果要在网络上传输,或者保存到磁盘上,就需要把str变为以字节为单位的bytes。以Unicode表示的str通过encode()方法可以编码为指定的bytes。
ASCII 只能表示英文 ,UTF-8可以表示所有语言。 所以 'ABC'.encode('ascii') , '中文'.encode('utf-8') 都是对的,可是 '中文'.encode('ascii')就是错的。
bytes -> str (decode方法):
如果我们从网络或磁盘上读取了字节流,那么读到的数据就是bytes。要把bytes变为str,就需要用decode()方法:
如果bytes中包含无法解码的字节,decode()方法会报错:
如果bytes中只有一小部分无效的字节,可以传入errors='ignore'忽略错误的字节。比如:
>>> b'\xe4\xb8\xad\xff'.decode('utf-8', errors='ignore')'中'
在python源文件里指定编码
由于Python源代码也是一个文本文件,所以,当你的源代码中包含中文的时候,在保存源代码时,就需要务必指定保存为UTF-8编码。
通常在文件开头写上这两行:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
第一行注释是为了告诉Linux/OS X系统,这是一个Python可执行程序,Windows系统会忽略这个注释;
第二行注释是为了告诉Py
同时必须并且要确保文本编辑器正在使用UTF-8 without BOM编码
(7):格式化:
用%运算符就是用来格式化字符串:
有几个%?占位符,后面就跟几个变量或者值,顺序要对应好如果你不太确定应该用什么,%s永远起作用,它会把任何数据类型转换为字符串:
>>> 'Age: %s. Gender: %s' % (25, True)
'Age: 25. Gender: True'有些时候,
字符串里面的%是一个普通字符怎么办?这个时候就需要转义,用%%来表示一个%:
>>> 'growth rate: %d %%' % 7'
growth rate: 7 %'
常见的占位符有:
占位符 | 替换内容 |
%d | 整数 |
%f | 浮点数 |
%s | 字符串 |
%x | 十六进制整数 |
使用字符串的format()方法格式化字符串
它会用传入的参数依次替换字符串内的占位符{0}、{1}……,不过这种方式写起来比%要麻烦得多
>>> 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)'
Hello, 小明, 成绩提升了 17.1%'
3.4 布尔值:
-
用True、False表示布尔值(请注意大小写)
布尔值可以用and、or和not运算
布尔值经常用在条件判断中,比如:
if age >= 18:print('adult')else:print('teenager')
3.5 空值:
空值是Python里一个特殊的值,用None表示。None不能理解为0,因为0是有意义的,而None是一个特殊的空值。Python还提供了列表、字典等多种数据类型,还允许创建自定义数据类型。
4.数据结构:
4.1列表list:
list是一种有序的集合,可以随时添加和删除其中的元素。
list 特征:
(1): list 里面的元素的数据类型也可以不同
(2): list元素也可以是另一个list,此时list可以看成是一个二维数组,类似的还有三维、四维……数组
s = ['python', 'java', ['asp', 'php'], 'scheme']则s[2][1]就是指php
(3): list中一个元素也没有,就是一个空的list,它的长度为0
(4): python中数组(list/array)不会复制,而是直接引用,此时要特别注意,如下图,b = a,此时改变b就会改变a,所以有时候使用不当,会导致某个变量莫名其妙就发生了变化。
对于单个变量,如:
将数据直接赋值进行复制后,变量前后独立,是位于两块空间内的。但对于数组(list 或 numpy.array):
相当于引用,是位于同一块空间内的
(5):列表是python内置的可变序列,是包含若干元素的有序连续内存区间,其元素数据类型可以各不相同。当列表增加或删除元素时,列表对象将自动进行内存的扩展或收缩,从而保证元素间没有间隙。python列表内存的自动管理可以大幅减少程序员负担,但是也可能造成列表内大量元素的移动,效率低。所以,除非必要,否则应该尽量从列表尾部进行元素的增删操作。
因为列表的指针使用的是连续内存空间存储-元素不是,所以耗内存。
list可以进行的操作有:
(1):用len()函数可以获得list元素的个数
(2):用索引来访问list中每一个位置的元素,记得索引是从0开始的。
比如classmates[0].
还可以用-1做索引,直接获取最后一个元素。比如classmates[-1] 以此类推,可以获取倒数第2个、倒数第3个。
当索引超出了范围时,Python会报一个IndexError错误,所以,要确保索引不要越界,记得最后一个元素的索引是len(classmates) - 1
(3): 用append()函数往list中追加元素到末尾
(4):用insert()函数把元素插入到指定的位置。
比如 classmates.insert(1, 'Jack'),是指在索引为1的地方插入数据。
(5):用pop()方法删除list末尾的元素
要删除指定位置的元素,用pop(i)方法,其中i是索引位置
(6): 要把某个元素替换成别的元素,可以直接赋值给对应的索引位置
>>> classmates[1] = 'Sarah'>>> classmates['Michael', 'Sarah', 'Tracy']
4.2 元组tuple:
tuple特征:
tuple和list非常类似,但是tuple一旦初始化就不能修改. 因为tuple不可变,所以代码更安全。如果可能,能用tuple代替list就尽量用tuple。
tuple的定义用圆括号 (), list的定义用方括号[]
tuple操作:
(1):用len()函数可以获得list元素的个数
(2):用索引来访问list中每一个位置的元素,记得索引是从0开始的。
tuple不能变,它也没有append(),insert()这样的方法。其他获取元素的方法和list是一样的,你可以正常地使用classmates[0],classmates[-1],但不能赋值成另外的元素。
tuple的陷阱:
(1):定义只有一个元素的tuple的时候,记得加上逗号。 因为括号()既可以表示tuple,又可以表示数学公式中的小括号,如果没有逗号,则会认为是数学公式的小括号,计算结果自然是1。 比如:定义只有一个元素1的tuple,应该是 t = (1,)
(2):tuple变成“可变”了:
比如下面的代码,tuple里面的list的值变了。其实 表面上看,tuple的元素确实变了,但其实变的不是tuple的元素,而是list的元素。tuple一开始指向的list并没有改成别的list.
所以,tuple所谓的“不变”是说,tuple的每个元素,指向永远不变。即指向'a',就不能改成指向'b',指向一个list,就不能改成指向其他对象,但指向的这个list本身是可变的!
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t('a', 'b', ['X', 'Y'])
4.3 字典dict:
dict全称dictionary,在其他语言中也称为map,使用键-值(key-value)存储,具有极快的查找速度。
表示:d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
dict特征:
(1):为什么dict查找速度这么快?因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字,我们要查某一个字,一个办法是把字典从第一页往后翻,直到找到我们想要的字为止,这种方法就是在list中查找元素的方法,list越大,查找越慢。
第二种方法是先在字典的索引表里(比如部首表)查这个字对应的页码,然后直接翻到该页,找到这个字。无论找哪个字,这种查找速度都非常快,不会随着字典大小的增加而变慢。dict就是第二种实现方式。
(2):由于一个key只能对应一个value,所以,多次对一个key放入value,后面的值会把前面的值冲掉
(3):如果key不存在,dict就会报错。
要避免key不存在的错误,有两种办法,
一是通过in判断key是否存在
>>> 'Thomas' in dFalse
二是通过dict提供的get()方法,如果key不存在,可以返回None,或者自己指定的value:
>>> d.get('Thomas')
>>> d.get('Thomas', -1)-1
(4): dict内部存放的顺序和key放入的顺序是没有关系的
(5):dict的key必须是不可变对象, 这是因为dict根据key来计算value的存储位置,如果每次计算相同的key得出的结果不同,那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法(Hash)。 要保证hash的正确性,作为key的对象就不能变。在Python中,字符串、整数等都是不可变的,因此,可以放心地作为key。而list是可变的,就不能作为key。
(6): 和list比较,dict有以下几个特点:
1.查找和插入的速度极快,不会随着key的增加而变慢;
2.需要占用大量的内存,内存浪费多。
所以,dict是用空间来换取时间的一种方法。
dict操作:
(1): 用pop(key)方法删除一个key
(2): 根据key值查询value值 比如: d['Michael']
(3): 用in方法判断是否存在某个key
(4): 用get方法判断是否存在某个key
4.4 集合set:
set和dict类似,也是一组key的集合,但不存储value。
由于key不能重复,所以,在set中,没有重复的key。
set特征:
(1):重复元素在set中自动被过滤
(2): set的原理和dict一样,所以,同样不可以放入可变对象,因为无法判断两个可变对象是否相等,也就无法保证set内部“不会有重复元素”。试试把list放入set就会报错。
set操作:
(1): 通过add(key)方法可以添加元素到set中,可以重复添加,但不会有效果,因为set会自动过滤重复元素
(2): 通过remove(key)方法可以删除元素
(3): 两个set可以做数学意义上的交集、并集等操作
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2{2, 3}
>>> s1 | s2{1, 2, 3, 4}
5.条件判断
5.1 if语句的完整形式:
if :
elif :
elif :
else:
5.2 if判断条件还可以简写:
if x: print('True')
只要x是非零数值、非空字符串、非空list等,就判断为True,否则为False。
5.3 有输入的条件判断:
用input()读取用户的输入,然后进行判断。
s = input('birth: ')
birth = int(s)
if birth < 2000:
print('00前')
else:
print('00后')
需要注意因为input()返回的数据类型是str,str不能直接和整数比较,必须先把str转换成整数
6.循环
6.1 for...in循环
依次把list或tuple中的每个元素迭代出来。比如:
sum = 0for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:sum = sum + xprint(sum)
6.2 while循环
只要条件满足,就不断循环,条件不满足时退出循环。比如:
sum = 0
n = 99
while n > 0:
sum = sum + n
n = n - 2
print(sum)
3-4总结:
1.数据类型,数据结构汇总:
类型 | 特征 | 表示 | 操作 |
整数 | 正整数负整数 | 0xff00 ; 9 | |
浮点数 | 小数(正负) | 1.23 ; 1.23e9 | |
字符串 | 1.utf-8 编码 2.格式化 %d 整数, %f浮点数, %s字符串, %x十六进制 format() | 1. 'abc' 2. 表示单引号 "'" 3. 转义字符\ 'I\'m \"OK\"!' 4. 用r表示不转义 print(r'\\\t\\') 5. 多行 print('''line1... line2... line3''') | |
布尔值 | True、False | ||
空值 | None | ||
list | 1.有序连续内存区间 2.元素的数据类型也可以不同 3.list元素也可以是另一个list 4.不会复制,而是直接引用,所以改变引用的变量的值会导致原来的值变化 | a = [1,2,3] | 1.len()2.索引访问,赋值3.append()4.insert()5.pop() |
tuple | tuple和list非常类似,但是tuple一旦初始化就不能修改 | t = (1,)t = (1,2,3) | 1.len() 2.索引访问 |
dict | 1.dict的key必须是不可变对象,而list是可变的,就不能作为key 2.使用键-值(key-value)存储 | d = {'Michael': 95, 'Bob': 75, 'Tracy': 85} | 1.用pop(key)方法删除一个ke y2.根据key值查询value值 比如: d['Michael'] 3.用in方法判断是否存在某个key : 'Thomas' in d 4.用get方法判断是否存在某个key : d.get('Thomas') |
set | 1.set和dict类似,也是一组key的集合,但不存储value 2.set不可以放入可变对象,list是可变对象,不能放入set3.set会自动过滤重复元素 | set([1, 2, 3]) | 1.通过add(key)方法可以添加元素到set中 2.通过remove(key)方法可以删除元素 3.两个set可以做数学意义上的交集、并集等操作 |
2.不可变对象
str是不变对象,而list是可变对象可变对象:
对于可变对象,比如list,对list进行操作,list内部的内容是会变化的,
比如:
>>> a = ['c', 'b', 'a']
>>> a.sort()
>>> a['a', 'b', 'c']
不可变对象,比如str,对str进行操作后,str内部的内容不会变化,比如:
>>> a = 'abc'
>>> b = a.replace('a', 'A')
>>> b'Abc'
>>> a'abc'
a是一个变量,它指向的内容是‘abc’,当我们调用replace方法的时候,作用是在字符串对象‘abc’上,replace方法创建了一个新字符串‘Abc’并返回变量b指向这个新的字符串。所以,对于不变对象来说,调用对象自身的任意方法,也不会改变该对象自身的内容。相反,这些方法会创建新的对象并返回,这样,就保证了不可变对象本身永远是不可变的。