本文主要是学习Python基础:
Python数据类型和变量 字符串和编码 list和tuple 条件判断 循环 dict和set
本文根据廖雪峰的官方网站-Python教程,认真学习,一步一步实操并且详细记录。
在此,特别感谢廖雪峰老师。
Python2.x与Python3.x
之后补上。。。。。。
升级Ubuntu15.10系统的Python
Ubuntu15.10系统默认安装的Python为2.7.10
安装Python3.5
sudo apt-get install python3.5
注:由于Ubuntu底层采用的是Python2.*,Python3与Python2是互不兼容的,但是不能卸载Python2,只需要将默认的Python指向Python3
之前安装的Python3.5默认是安装在/usr/local/lib/python3.5目录下,需要删除默认python link文件,重新建立连接关系
rm /usr/bin/python
ln -s /usr/bin/python3.5 /usr/bin/python
第一个Python程序
直接在python交互式命令行中输入想要执行的代码,回车就可以立即得到代码的执行结果
python打印指定的文字,使用print()函数;将打印的文字用单引号或者双引号括起来!
800+300print("hello python")print('hello world')
Python基础
Python是一种编程语言,所以它也就有自己的一套语法规则。
编译器或者解释器负责把符合语法规则的程序代码转换成CPU能够执行的机器码,然后执行。
Python的语法比较简单,采用缩进的方式,写出来的代码如下所示:
(官网截图)
以#开头的语句为注释,注释是给开发者看的,可以使任意内容,解释器会忽略掉注释。
其他每一行都是一个语句,当语句以冒号“:”结尾时,缩进的语句视为代码块。
缩进能够强迫我们写出格式化的代码,但是没有规定缩进是几个空格还是Tab。按照约定俗成的管理,应该始终坚持使用4个空格的缩进。
特别注意:Python程序是大小写敏感的。
输入和输出
之前有提到print(),那就先从输出开始
用print()将所要输出的字符串作为参数添加在括号里面,并用单引号或者双引号括起来
print('hello python !')
print()函数也可以接受多个字符串,之间用逗号“,”隔开,就可以连成一串输出:
print('I want to speak good english !')
print("I","want","to ","speak","good","english","!")
注:print()函数会依次打印每个字符串,遇到逗号“,”会输出一个空格
print()也可以打印整数,或者计算结果,例如:
>>> print(888)888>>> print(888+111)999
人性化打印计算结果:
>>> print("555+111=",555+111)555+111= 666
下来我们说一说输入:
和其他语言一样,python给我们提供了输入函数input(),可以让用户输入字符串,并且存放到一个变量里面
>>> name=input()hjr
当输入name=input()并且按下回车之后,python交互式命令终端就等待你的输入了。这时你可以输入任意字符串,然后按回车完成输入。
输入完成后,不会有任何提示,python交互式命令终端又回到>>>状态。
>>> name'hjr'
刚才将输入的内容存放到变量name里面了,我们可以直接在命令行里面输入变量名name,查看变量的内容。
打印name变量的内容,除了直接在命令行里面输入变量名name回车查看变量内容之外,还可以使用我们之前学到的print()函数:
>>> print(name)hjr
小例子:
>>> name=input("please enter your name : ") please enter your name : hjr
>>> print('hello,',name)hello, hjr
>>> print(1024*768)786432
数据类型和变量
整数:
Python可以处理任意大小的整数(包括负整数),在程序中的表示方法和数学上的写法一模一样。例如:
1200-83410
浮点数:
浮点数,即:小数。之所以称为浮点数,是因为按照科学计数法表示时,一个浮点数的小数点位置是可变的,比如:1.23x109(上标)和12.3x108(上标)是完全相等的。
浮点数可以用数学写法,如:1.23,3.14,-9.01等。
对于很大或者很小的浮点数,就必须使用科学计数法表示,把10用e代替,1.23x109(上标)就是1.23e9或者12.3e8,0.000012可以写成1.2e-5等。
注:整数和浮点数在计算机内部存储的方式是不同的。整数运算永远是精确的(包括除法),而浮点数运算则可能会有四舍五入的误差。
字符串:
字符串是以单引号(‘ ’)或者双引号(“ ”)括起来的任意文本,例如 ‘qaz’,“wsx” 等。
(‘ ’)(“ ”)本身只是一种表示方式,不是字符串的一部分。因此,字符串‘abc’只有a,b,c这三个字符。如果(‘)本身也是一个字符,那就可以用(“ ”)括起来,例如:”I’m OK”包含的字符是(I)(’)(m)(空格)(O)(K)这六个字符。
如果字符里面既包含(’)又包含(“)的话,则可以使用转义字符(\)来标识,如:
'I\'m \"OK\"!'
表示的字符串内容是:
>>> print('I\'m \"OK\"!')I'm "OK"!
转义字符(\)可以转义很多字符,比如:
\n 表示换行
\t 表示制表符
等。。。
字符(\)本身也要转义,所以(\)表示的字符就是(\)。
在Python的交互式命令终端用print()打印字符串查看:
>>> print('I\'m learning python. \nhjr ')I'm learning python. hjr >>> print('\\\n\\')\\
如果字符串里面有很多字符需要转义,就需要加很多(\),为了简化,Python还允许用(r’ ‘)或(r“ ”)表示(’ ‘)或(“ ”)内部的字符串默认不转义。
>>> print('\\\t\\')\ \>>> print(r'\\\t\\')\\\t\\>>> print(r"\\\t\\")\\\t\\
如果字符串内部有很多换行,用(\n)写在一行里面不好阅读,为了简化,Python允许用(“‘…’”)的格式表示多行内容。
注:三个单引号
>>> print('''yiyou... hjr... yizheyouye... python... hadoop... spark''')yiyouhjryizheyouyepythonhadoopspark
>>> print("""yiyou... hjr... yizheyouye... python... hadoop... spark... good""")yiyouhjryizheyouyepythonhadoopsparkgood
布尔值:
布尔值和布尔代数的表示完全一致,一个布尔值只有True和False两种值,也就是说要么True,要么False。在Python中,可以直接使用True或者False表示布尔值(注意大小写),也可以通过布尔运算计算出来:
>>> TrueTrue>>> FalseFalse>>> 8>3True>>> 2>10False
布尔运算:and / or / not
and运算:与运算
只有所有都为True,and运算结果才是True:
>>> True and TrueTrue>>> True and FalseFalse>>> False and FalseFalse>>> 4>1 and 8<12True
or运算:或运算
只要其中有一个为True,or运算结果就是True:
>>> True or TrueTrue>>> True or falseTrue>>> False or FalseFalse>>> 8<3 or 9>1True
not运算:非运算
它是一个单目运算符,把True变成False,False变成True:
>>> not TrueFalse>>> not FalseTrue>>> not 1>8True
布尔值经常用在条件判断中,如:
if age >= 18:print('adult')else:print('teenager')
空值:
空值是Python里面一个特殊的值,用None表示。
注:None不能理解为0,因为0是有意义的,而None是一个特殊的空值。
变量:
计算机程序中,变量不仅可以是数字,也可以是任意数据类型
变量在程序中就是一个变量名表示,变量名必须是大小写英文/数字/和_下划线的组合,而且不能用数字开头。
a=7
变量a是一个整数
hjr_007="yiyou"
变量hjr_007是一个字符串
Answer=False
变量Answer是一个布尔值False
在Python中,等号(=)是赋值语句,可以把任意数据类型赋值给变量,同一个变量可以反复赋值,而且可以是不同类型的变量,如:
>>> a=8341>>> print(a)8341>>> a='ABC'>>> print(a)ABC
这种变量本身类型不固定的语言称之为动态语言,与之对应的是静态语言。
静态语言在定义变量时必须指定变量类型,如果赋值的时候类型不匹配,就会报错。比如:Java就是静态语言,赋值语句如下就会报错:
int a=8341; //a是整数类型变量a='ABC'; //报错:不能把字符串赋值给整形变量
和静态语言相比,动态语言更加灵活,就是这个原因。
注意:不能把赋值语句的等号等同于数学的等号。
X=8X=X+3
析:X=X+3,在计算机程序中,赋值语句先计算右侧的表达式X+3,得到结果11,在赋值给X。由于X之前的值是8,重新赋值后,X的值变成11。
变量在计算机内存中的表示:
a='ABC'
当我们写a=‘ABC’时,Python解释器做了两件事请:
1)在内存中创建了一个‘ABC’的字符串;
2)在内存中创建了一个名为a的变量,并把它指向‘ABC’。
也可以把一个变量a赋值给另一个变量b,这个操作实际上是把变量b指向变量a所指向的数据。
>>> a='ABC'>>> b=a>>> a='XYZ'>>> print(b)ABC
1)执行a=‘ABC’,解释器创建了字符串‘ABC’和变量a,并把a指向‘ABC’。
2)执行b=a,解释器创建了变量b,并把b指向a指向的字符串’ABC‘。
3)执行a=’XYZ‘,解释器创建了字符串,并把a的指向改为’XYZ‘,但是b并没有更改。
所以,最后打印变量b的结果自然就是’ABC‘了。
常量:
常量就是不能变得变量,特殊的变量。比如常用的数学常数π就是一个常量。
在Python中,通常用全部大写的变量名表示常量:
PI=3.14159265359
但事实上,PI任然是一个变量,Python根本没有任何机制保证PI不会被改变,所以,用全部大写的变量名表示常量只是一个习惯上的用法。
附:整数的除法为什么是精确的
在Python中,有两种除法,一种除法是(/):
>>> 10/33.3333333333333335
(/)除法计算结果是浮点数,即使是两个整数恰好整除,结果也是浮点数:
>>> 18/36.0
还有一种除法是(//),称为地板除,两个整数的除法任然是整数:
>>> 10//33
整数的地板除(//)永远是整数,即使是除不尽的情况。
要做精确的除法,使用(/)就可以。
无论整数做(//)除法还是取余数,结果永远是整数,所以说,整数运算结果永远是精确的。
小例子:
>>> n=123>>> print(n)123>>> f=456.789>>> print(f)456.789>>> s1='Hello World'>>> print(s1)Hello World>>> s2='Hello,\'Adam\''>>> print(s2)Hello,'Adam'>>> s3=r'Hello,"Bart"'>>> print(s3)Hello,"Bart">>> s4=r'''Hello,... Lisa!... Roky!'''>>> print(s4)Hello,Lisa!Roky!
字符串和编码
字符串是一种数据类型,但是,字符串比较特殊的是还有一个编码问题。
因为计算机只能处理数字,如果要处理文本,就必须先把文本转换为数字才能处理。
最早的计算机在设计时采用8个比特(bit)作为一个字节(byte),所以,一个字节能表示的最大的整数就是255(二进制11111111=十进制255),如果要表示更大的整数,就必须用更多的字节。比如两个字节可以表示的最大整数是65535,4个字节可以表示的最大整数是4294967295。
由于计算机是美国人发明的,因此,最早只有127个字母被编码到计算机里,也就是大小写英文字母/数字和一些符号,这个编码表被称为ACSII编码,比如大写字母A的编码是65,小写字母z的编码是122。
我们要处理中文显然一个字节是不够的,至少得两个字节,而且还不能和ASCII编码冲突,所以,中国制定了GB2312编码,用来把中文编进去。
全世界有上百中语言,日本把日文编到Shift_JIS里,韩国把韩文编到Euc-kr里,各国有各国的标准,所以就会不可避免的出现冲突,结果就是,在多语言混合的文本中,显示出来就会有乱码。
因此,Unicode应运而生。
Unicode把所有的语言都统一到一套编码里面,这样就不会有乱码问题了。
Unicode标准也在不断发展,但是常用的是用两个字节表示一个字符(如果用到非常偏僻的字符,就需要4个字节)。现代操作系统和大多数编程语言都直接支持Unicode。
ASCII编码与Unicode编码的区别:
ASCII编码是一个字节,Unicode编码通常是两个字节。
字母(A)用ASCII编码是十进制的65,二进制的01000001;
字符(0)用ASCII编码是十进制的48,二进制的00110000;
(注意:字符‘0’和整数0是不同的)
汉字(中)已经超出了ASCII编码的范围,用Unicode编码是十进制的20013,二进制的01001110 00101101。
如果把ASCII编码的A用Unicode编码,只需要在前面补0就可以了,故,A的Unicode编码是00000000 01000001。
问题:
如果统一成Unicode编码,乱码问题从此消失了。但是,如果我们写的文本全部是英文的话,用Unicode编码比ASCII编码需要多一倍的存储空间,在存储和传输方面就十分不划算。
所以,本着节约的精神,又出现了把Unicode编码转换为“可变长编码”的UTF-8编码。
UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节,常用的英文字母被编码成1个字节,汉字通常是3个字节,只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符,用UTF-8编码就能节省空间:
从上面的表格可以发现,UTF-8编码还有一个额外的好处,就是ASCII编码实际上可以被看成UTF-8编码的一部分,所以,大量支持ASCII编码的历史遗留软件可以在UTF-8编码下继续工作。
总结一下,计算机系统通用的字符编码工作方式:
在计算机内存中,统一使用Unicode编码,
当需要保存到硬盘或者需要传输的时候,就转换为UTF-8编码。
用记事本编辑的时候,从文件读取的UTF-8字符被转换为Unicode字符到内存里,编辑完成后,保存的时候再把Unicode字符转换为UTF-8字符保存到文件。
同理,浏览网页的时候,服务器会把动态生成的Unicode内容转换为UTF-8在传输到浏览器。
所以我们会看到很多网页的源码上会有类似的信息,表示网页使用的是UTF-8编码。
Python的字符串
在最新的Python3中,字符串是以Unicode编码的,所以,Python的字符串支持多国语言,比如:
>>> print('包含中文的string')包含中文的string
对于单个字符的编码,Python提供了ord()函数获取字符的整数表示,chr()函数把编码转换为对应的字符:
>>> ord('A')65>>> ord('中')20013>>> chr(66)'B'>>> chr(25991)'文'
如果知道字符的整数编码,还可以用十六进制写str:
>>> '\u4e2d\u6587''中文'
两种写法完全等价。
由于Python的字符串类型是str,在内存中以Unicode表示,一个字符对应若干个字节。如果要在网络上传输,或者保存到磁盘上,就需要把str变为以字节为单位的bytes。
Python对bytes类型的数据用带b前缀的单引号或双引号表示:
x=b'ABC'
注意区分‘ABC’和b’ABC’,前者是str,后者虽然内容显示的和前者一样,单bytes的每个字附都占用一个字节。
以Unicode表示的str通过encode()方法可以编码为指定的bytes,如下:
>>> 'ABC'.encode('ascii')b'ABC'>>> '中文'.encode('utf-8')b'\xe4\xb8\xad\xe6\x96\x87'>>> '中文'.encode('ascii')Traceback (most recent call last):File "<stdin>", line 1, in <module>UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)
纯英文的str可以用ASCII编码为bytes,内容是一样的,
含有中文的str可以用UTF-8编码为bytes。
含有中文的str无法用ASCII编码,因为中文编码的范围超过了ASCII编码的范围,Python会报错奥!
在bytes中,无法显示为ASCII字符的字节,用(\x##)显示。
反过来,如果我们从网络或磁盘上读取了字节流,那么读取到的数据就是bytes。要把bytes变为str,就需要用decode()方法:
>>> b'ABC'.decode('ascii')'ABC'>>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')'中文'
要计算str包含多少个字符,可以用len()函数:
>>> len('ABC')3>>> len('中文')2
len()函数计算的是str的字符数,如果换成bytes,len()函数就计算字节数:
>>> len(b'ABC')3>>> len(b'\xe4\xb8\xad\xe6\x96\x87')6>>> len('中文'.encode('utf-8'))6
可见,一个中文字符经过UTF-8编码后通常会占用3个字节,而一个英文字符只占用1个字节。
在操作字符串时,我们经常遇到str和bytes的相互转换。为了避免乱码问题,应当始终坚持使用UTF-8编码对str和bytes进行转换。
由于Python源代码也是一个文本文件,所以,当你的源代码中包含中文的时候,在保存源代码的时候,就需要务必指定保存为UTF-8编码。当python解释器读取源代码时,为了让它按UTF-8编码读取,我们通常在文件开头写上这两行:
#!/usr/bin/env python3# _*_ coding: utf-8 _*_
第一行注释是为了告诉Linux/OS X系统,这是一个Python可执行程序,Windows系统会忽略这个注释;
第二行注释是为了告诉Python解释器,按照UTF-8编码读取源代码,否则,你在源代码中写的中文输出可能会有乱码。
声明了UTF-8编码并不意味着你的(.py)文件就是UTF-8编码的,必须并且要确保文本编辑器正在使用UTF-8 without BOM编码。
格式化
如何输出格式化的字符串?
我们经常会输出类似“亲爱的×××你好!你××月的话费是××,余额是××”之类的字符串,而×××的内容都是根据变量变化的,所以,需要一种简便的格式化字符串的方式。
在Python中,采用的格式化方式和C语言是一致的,用(%)实现,例如:
>>> 'Hello,%s' % 'Python''Hello,Python'>>> 'Hi,%s,you have $%d.'%('hjr',999999)'Hi,hjr,you have $999999.'
(%)运算符就是用来格式化字符串的。
在字符串内部,%s表示用字符串替换,%d表示用整数替换,有几个(%?)占位符,后面就跟几个变量或者值,顺序要对应好。
如果只有一个(%?),括号可以省略。
常见的占位符有:
%d 整数
%f 浮点数
%s 字符串
%x 十六进制整数
其中,格式化整数和浮点数还可以指定是否补0和整数与小数的位数:
>>> '%2d-%02d' % (3,1)' 3-01'>>> '%.2f' % 3.14159265359'3.14'
如果你还不太确定应该用什么,(%s)永远起作用,它会把任何数据类型转化为字符串:
>>> 'Age: %s. Gender: %s' % (25,True)'Age: 25. Gender: True'
有些时候,字符串里面的%是一个普通字符怎么办?(百分比)这个时候就需要转义,用%%来表示%:
>>> 'growth rate %d %%' % 8'growth rate 8 %'
小练习:
小明的成绩从去年的72分提升到了今年的85分,请计算小明成绩提升的百分点,并用字符串格式化显示出’xx.x%’,只保留小数点后1位:
>>> s1=72>>> s2=85>>> r=(s2-s1)/s1>>> 'growth rate : %.1f %%' % r'growth rate : 0.2 %'
使用 list 和 tuple
list
Python内置的一种数据类型是列表:list。
list是一种有序的集合,可以随时添加和删除其中的元素。
>>> classmates = ['yiyou','hjr','lr','hjj','lqq']>>> classmates['yiyou', 'hjr', 'lr', 'hjj', 'lqq']
变量classmates就是一个list。用len() 函数可以获得list元素的个数:
>>> len(classmates)5
用索引来访问list中每一个位置的元素,注意:索引是从0开始的哟:
>>> classmates[0]'yiyou'>>> classmates[1]'hjr'>>> classmates[2]'lr'>>> classmates[3]'hjj'>>> classmates[4]'lqq'>>> classmates[5]Traceback (most recent call last):File "<stdin>", line 1, in <module>IndexError: list index out of range
当索引超出了范围时,Python会报一个IndexError错误,所以,要确保索引不要越界,记得最后一个元素的索引是len(classmates)-1。
如果要取最后一个元素,除了计算索引位置外,还可以用-1做索引,直接获取最后一个元素:
>>> classmates[-1]'lqq'
以此类推,可以获取倒数第二个,倒数第三个等:
>>> classmates[-2]'hjj'>>> classmates[-3]'lr'>>> classmates[-4]'hjr'>>> classmates[-5]'yiyou'
list是一个可变的有序列表,所以,可以往list中追加元素到末尾:
>>> classmates.append('fyh')>>> classmates['yiyou', 'hjr', 'lr', 'hjj', 'lqq', 'fyh']
也可以把元素插入到指定的位置,例如索引号为0的位置:
>>> classmates.insert(0,'yizheyouye')>>> classmates['yizheyouye', 'yiyou', 'hjr', 'lr', 'hjj', 'lqq']
要删除list末尾的元素,用pop()方法:
>>> classmates.pop()'fyh'>>> classmates['yiyou', 'hjr', 'lr', 'hjj', 'lqq']
要删除指定位置的元素,用pop(i)方法,其中i是索引位置:
>>> classmates.pop(0)'yizheyouye'>>> classmates['yiyou', 'hjr', 'lr', 'hjj', 'lqq']
要把某个元素替换成别的元素,可以直接赋值给对应的索引位置:
>>> classmates[4]='fyh'>>> classmates['yiyou', 'hjr', 'lr', 'hjj', 'fyh']
list里面的元素的数据类型也可以不同,比如:
>>> L=['Apple',8341,True]>>> L['Apple', 8341, True]
list元素也可以是另一个list,例如:
>>> s=['python','scala',['spark','hadoop','flink'],'ruby','go']>>> s['python', 'scala', ['spark', 'hadoop', 'flink'], 'ruby', 'go']>>> len(s)5
注意:s只有5个元素,其中s[2]又是一个list,如果拆开写就容易理解了:
>>> p=['spark','hadoop','flink']>>> s=['python','scala',p,'ruby','go']>>> s['python', 'scala', ['spark', 'hadoop', 'flink'], 'ruby', 'go']
想要拿到’spark‘,可以写p[0]或者s[2][0],因此,s可以看成一个二位数组,类似的还有三维/四维。。。数组,不过,很少用到。
如果一个list中一个元素都没有,就是一个空的list,它的长度为0:
>>> L=[]>>> len(L)0
tuple
另一种有序列表叫元祖:tuple
tuple和list非常类似,但是,tuple一旦初始化,就不能修改。
例如:同样是列出同学的名字:
>>> classmates=('hjr','lr','hjj','lqq')
现在,classmates这个tuple不能变了,它也没有append(),insert()这样的方法。其他获取元素的方法和list是一样的,我们可以正常使用classmates[0],classmates[-1],当然不能赋值给另外的元素。
不可变得tuple有什么意义呢?因为tuple不可变,代码更安全。如果可变,能用tuple代替list就尽量用tuple。
tuple陷阱:
当你定义一个tuple时,在定义的时候,tuple的元素就必须被确定下来,比如:
>>> t=(1,2,3)>>> t(1, 2, 3)
如果要定义一个空tuple,就可以写成():
>>> t=()>>> t()
但是,要定义一个只有一个元素的tuple,如果我们这么定义:
>>> t=(1)>>> t1
这么定义的就不是tuple,是1这个数字!
这是因为括号()既可以表示tuple,又可以表示数学公式中的小括号,这就产生了歧义,因此,Python规定,在这种情况下,按小括号进行计算,计算结果自然是1咯。
所以,只有一个元素的tuple 定义 时必须加一个逗号(,),来消除歧义:
>>> t=(1,)>>> t(1,)
Python在 显示 只有一个元素的tuple时,也会加一个逗号(,),以免我们误解成数学计算意义上的括号。
最后,我们看一个“可变的”tuple:
>>> t=('a','b',['A','B'])>>> t('a', 'b', ['A', 'B'])>>> t[2][0]='X'>>> t[2][1]='Y'>>> t('a', 'b', ['X', 'Y'])
这个tuple定义的时候有三个元素,分别是’a‘,’b‘和一个list。
表面上看,tuple的元素确实变了,但实际变的不是tuple的元素,而是list的元素。
tuple一开始指向的list并没有改成别的list,所以,tuple所谓的“不变”是说,tuple的每一个元素,指向定义了以后就永远不变。
即:
指向’a‘,就不能改变成’b‘,指向一个list,就不能改成指向其他对象,但指向的这个list本身是可以改变的!
了解了“指向不变”后,要创建一个内容也不变的tuple怎么做呢?
那就必须保证tuple的每一个元素本身也不能变。
小练习:
>>> L=[['Apple','Google','Microsoft'],['Java','Python','Ruby','PHP'],['Adam','Bart','Lisa']]>>> L[['Apple', 'Google', 'Microsoft'], ['Java', 'Python', 'Ruby', 'PHP'], ['Adam', 'Bart', 'Lisa']]>>> print(L[0][0])Apple>>> print(L[1][1])Python>>> print(L[2][2])Lisa
小结:
list和tuple是Python内置的有序集合,一个可变,一个不可变。我们根据需要选择使用。
条件判断
计算机之所以能够做到很多自动化的任务,因为它可以自己做条件判断。
例如,输入用户年龄,根据年龄打印不同的内容,在Python程序中,用if语句实现:
age = 20if age >= 18:print('your age is', age)print('adult')
根据Python的缩进规则,如果if语句判断是True,就把缩进的两行print()语句执行了,否则,什么也不做。
也可以给if添加一个else语句,意思是,
如果if判断是False,不执行if语句内容,而是执行else语句内容:
age = 8if age >= 18:print('your age is', age)print('adult')else:print('your age is', age)print('teenager')
注意:不能少写冒号(:)
上面的判断还是很粗略的,完全可以用elif做更细致的判断:
age = 3if age >= 18:print('adult')elif age >= 6:print('teenager')else:print('kid')
elif是else if的缩写,完全可以有多个elif,所以if语句的完整形式就是:
if <条件判断1>:<执行1>elif<条件判断2><执行2>elif<条件判断3><执行3>else:<执行4>
if语句执行有个特点,它是从上往下判断,如果在某个判断上是True,把该判断对应的语句执行后,就会忽略掉剩下的elif和else语句。
所以,请测试并解释为什么下面的程序打印的是teenager:
age = 20if age >= 6:print('teenager')elif age >= 18:print('adult')else:print('kid')
满足第一个if后,执行完就跳出了判断语句。
if判断条件还可以简写,例如:
if x:print('True')
只要x是非零数值/非空字符串/非空list等,就判断为True,否则为False。
Input
我们有时候会用input()读取用户的输入,这样可以自己输入,程序运行的很有意思:
birth = input('birth:')if birth < 2000:print('00 qian')else:print('00 hou')
报错了:
这是因为input()返回的数据类型是str,而str不能直接和整数比较,必须先把str转换成整数。
Python提供了int()函数来完成这件事情:
s = input('birth:')birth = int(s)if birth < 2000:print('00 qian')else:print('00 hou')
再次运行,就可以得到正确的结果。但是,如果输入abc字符串呢?
又会得到一个错误信息:
int()函数发现一个字符串并不是合法的数字时就会报错,程序就退出了。
小练习:
小明身高1.75,体重80.5kg。请根据BMI公式(体重除以身高的平方)帮小明计算他的BMI指数,并根据BMI指数:
低于18.5:过轻18.5-25:正常25-28:过重28-32:肥胖高于32:严重肥胖
# BMI值計算公式: BMI = 體重(公斤) / 身高*身高(公尺*公尺)# 例如:一個52公斤的人,身高是155公分,則BMI為 :# 52(公斤)/1.55*1.55 ( 公尺*公尺 )= 21.6# 體重正常範圍為 BMI=18.5~24height = 1.75weight = 80.5bmi = weight/(height*height)if bmi < 18.5:print('过轻')elif bmi >= 18.5 and bmi < 25:print('正常')elif bmi >= 25 and bmi < 28:print('过重')elif bmi >= 28 and bmi < 32:print('肥胖')elif bmi > 32:print('严重肥胖')else:print('Exception !')
修改一下:
# BMI值計算公式: BMI = 體重(公斤) / 身高*身高(公尺*公尺)# 例如:一個52公斤的人,身高是155公分,則BMI為 :# 52(公斤)/1.55*1.55 ( 公尺*公尺 )= 21.6# 體重正常範圍為 BMI=18.5~24height = 1.75weight = 80.5bmi = weight/(height*height)if bmi < 18.5:print('过轻')# elif bmi >= 18.5 and bmi < 25:elif 18.5 <= bmi < 25:print('正常')# elif bmi >= 25 and bmi < 28:elif 25 <= bmi < 28:print('过重')# elif bmi >= 28 and bmi < 32:elif 28 <= bmi < 32:print('肥胖')elif bmi > 32:print('严重肥胖')else:print('Exception !')
for 循环
计算1+2+3,我们可以直接写表达式:
>>> 1+2+36
要计算1+2+3+4+…+10,勉强也能写出来。
但是,要计算1+2+3+…+10000,直接写表达式是不明智的。
为了让计算机能计算成千上万次的重复运算,我们就需要循环语句。
Python的循环有两种,一种是for…in循环,依次把list或者tuple中的每一个元素迭代出来,如下:
names = ['hjr','lr','hjj','lqq']for name in names:print(name)
执行这段代码,会依次打印names中的每一个元素:
所以,for x in …循环就是把每个元素带入变量x,然后执行行缩进块的语句。
在比如我们想计算1-10的整数之和,我们可以用一个sum变量做累加:
sum = 0for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:sum = sum + x# sum += x //上面那句可以简写成这样print(sum)
如果要计算1-100的整数之和,从1写到100有点困难,幸好Python提供一个range()函数,可以生成一个整数序列,再通过list()函数就可以转换为list。
比如,range(5)生成的序列是从0开始小于5的整数:
>>> list(range(5))[0, 1, 2, 3, 4]
range(101)就可以生成0-100的整数序列,计算如下
sum = 0for x in range(101):sum = sum +xprint(sum)
while 循环
while循环,只要条件满足,就不断循环,条件不满足时退出循环。
比如我们计算100以内所有奇数之和,可以用while循环实现:
sum = 0n=99while n > 0:sum = sum + nn = n - 2print(sum)
在循环内部变量n不断自减,知道变为-1时,不再满足while条件,循环退出。
小练习:
利用循环依次对list中的每个名字打印出 Hello, xxx
names=['hjr','lr','hjj','lqq','yiyou']for name in names:print('hello,',name)
使用dict和set
dict
Python内置了字典:dict的支持,dict全称dictionary,在其他语言中也称为map,使用键-值(key-value)存储。具有极快的查找速度。
举个例子,假设要根据同学的名字查找对应的成绩,如果用list实现,需要两个list:
names = ['hjr','lr','hjj','lqq']scores = [95,85,75,65]
给定一个名字,在查找对应的成绩,就先要在names中找到对应的位置,再从scores取出对应的成绩,list越长,耗时就越长。
如果用dict实现,只需要一个”名字“-”成绩“的对照表,直接根据名字查找成绩,无论这个表多大,查找速度都不会变慢。
用Python写一个dict如下:
>>> d={'hjr':95,'lr':85,'hjj':75,'lqq':75}>>> d['lr']85
为什么dict查找速度这么快呢?因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字,我们要查某一个汉字,一个办法就是把字典从第一页往后翻,直到我们想要的字为止,这种方法就是在list中查找元素的方法,list越大,查找越慢。
第二种方法是先在字典的索引表里(比如部首表)查这个字对应的页码,然后直接翻到该页,找到这个字。无论找哪个字,这种查找速度都非常快,不会随着字典的大小的增加而变慢。
dict就是第二种实现方式,给定一个名字,比如‘Michael’,dict在内部就可以直接计算出Michael对应的存放成绩的”页码“,也就是95个数字存放在内存的地址,直接取出来,所以速度非常快。
这种key-value存储方式,在放进去的时候,必须根据key算出value的存放位置,这样,取的时候就能根据key直接拿到value。
把数据放入dict的方法,除了初始化时指定外,还可以通过key放入:
>>> d['Adam']=67>>> d['Adam']67
由于一个key只能对应一个value,所以,多次对一个key放入value,后面的值会把前面的值冲掉:
>>> d['Jack']=90>>> d['Jack']90>>> d['Jack']=88>>> d['Jack']88
如果key不存在,dict就会报错:
>>> d['Thomas']Traceback (most recent call last):File "<stdin>", line 1, in <module>KeyError: 'Thomas'
要避免key不存在的错误,有两种方法,
一是通过in判断key是否存在:
>>> 'Thomas' in dFalse
二是通过dict提供的get方法,如果key不存在,可以返回None,或者自己指定value:
>>> d.get('Thomas')>>> d.get('Thomas',-1)-1
注意:返回None的时候,Python的交互式命令行不显示结果。
要删除一个key,用pop(key)方法,对应的value也会从dict中删除:
>>> d{'hjr': 95, 'Jack': 88, 'lqq': 75, 'lr': 85, 'hjj': 75}>>> d.pop('Jack')88>>> d{'hjr': 95, 'lqq': 75, 'lr': 85, 'hjj': 75}
注意:dict内部存放的顺序和key放入的顺序是没有关系的。
和list比较,dict有以下几个特点:
1)查找和插入的速度极快,不会随着key的增加而增加;
2)需要占用大量的内存,内存浪费多。
而list相反:
1)查找和插入的时间随着元素的增加而增加;
2)占用空间小,浪费内存少。
故,dict是用空间来换取时间的一种方法。
dict可以用在需要告诉查找的很多地方,在Python代码中几乎无处不在,正确使用dict非常重要,
需要牢记的第一条就是dict的key必须是不可变对象。
这是因为dict根据key来计算value的存储位置,如果每次计算相同的key得出的结果不同,那dict内部就完全混乱了。
这个通过key计算存储位置的算法称为哈析算法(Hash)。
要保证hash的正确性,作为key的对象就不能变。在Python中,字符串/整数等都是不可变的,因此,可以放心的作为key。
而list是可变的,就不能作为key:
>>> key = [1,2,3]>>> d[key]='a list'Traceback (most recent call last):File "<stdin>", line 1, in <module>TypeError: unhashable type: 'list'
set
set和dict类似,也是一组key的集合,但不存储value。
由于key不能重复,所以,在set中,没有重复的key。
要创建一个set,需要提供一个list作为输入集合:
>>> s = set([1,2,3])>>> s{1, 2, 3}
注意:传入参数[1,2,3]是一个list,而显示的{1,2,3}只是告诉你这个set内部有1,2,3这3个元素,显示的顺序也表示set是有序的。
重复元素在set中自动被过滤:
>>> s = set([1,1,2,2,3,3])>>> s {1, 2, 3}
通过add(key)方法可以添加元素到set中,可以重复添加,但是不会有效果:
>>> s.add(4)>>> s{1, 2, 3, 4}>>> s.add(4)>>> s{1, 2, 3, 4}
通过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内部”不会有重复元素“。
我们把list放入set中,看看是否会报错:
思考:...
不可变对象
上面有说,str是不可变对象,而list是可变对象。
对于可变对象,比如list,对list进行操作,list内部的内容是会变化的。
例如:
>>> a = ['c','b','a']>>> a.sort()>>> a['a', 'b', 'c']
而对于不可变对象,比如str,对str进行操作:
>>> a = 'abc'>>> a.replace('a','A')'Abc'>>> a'abc'
虽然字符串有个replace()方法,也确实变出了‘Abc’,但变量a最后任是‘abc’,这该如何理解呢?
>>> a = 'abc'>>> b = a.replace('a','A')>>> b'Abc'>>> a'abc'
我们必须清楚,a是变量,而‘abc’才是字符串对象 !
有些时候,我们经常说,对象a的内容是‘abc’,但其实是指a本身是一个变量,它指向的对象的内容才是‘abc’:
当我们调用a.replace(‘a’,‘A’)的时,实际上调用方法replace是作用在字符串对象‘abc’上的,而这个方法虽然名字叫replace,但却没有改变字符串‘abc’的内容。
相反,replace方法创建了一个新字符串‘Abc’并且返回,如果我们用变量b指向该新字符串,就容易理解了,变量a任然指向原有的字符串‘abc’,但变量b却指向新字符串‘Abc’了:
所以,对于不可变对象来说,调用对象自身的任意方法,也不会改变该对象自身的内容。
相反,这些方法会创建新的对象并且返回,这样,就保证了不可变对象本身永远是不可变的。
小结:
使用key-value存储结构的dict在Python中非常有用,选择不可变对象作为key很重要,最常用的key是字符串。
tuple虽然是不可变对象,但是,试试把(1,2,3)和(1,[2,3])放入dict或set中。。。