Python学习教程(一)——初步认识

一、版本说明
      本学习教程所有代码都是基于Python2.7版本。
二、Python的第一个语句
      根据“国际惯例”,学习一门语言,总要先写一个“Hello World !”,那么来吧:
>>> print "Hello World !"
Hello World !
      看起来很简单,print语句打印出了“Hello World !”字符串,与大部分语言相比,我们发现语句结尾并没有加分号(“;”),Python中一行就是一个可执行语句,当然如果我们尝试加上分号也没有关系,并不会看到任何报错,但是这里还是建议不要加上分号。
三、数字运算
      除了上面简单的打印语句外,我们还可以直接进行数学运算操作,然后直接打印出运算结果,比如:
>>> 1+2
3
>>> 4*5
20
>>> 2 * math.pi * 20
125.66370614359172
>>> 1/2
0
      math.pi 是π(3.1415926...)。具体导入math的一些用法,后面会涉及到。这里只需要知道,如果要使用math,必须要先写上导入语句:import math。
      最后一个在计算1/2时,为什么会是0呢?这里因为整数除以整数时Python默认把小数点后面的数截掉了,嗯,就是截掉了,没有四舍五入。那如何才能得到我们预期的0.5呢?这里有两种方式:1)转换为用带小数点的实数进行运算;2)设置Python除法的执行方式;
1)转换为用带小数点的实数进行运算:
>>> 1.0/2.0
0.5
>>> 1/2.0
0.5
>>> 1.0/2
0.5
>>> 1./2
0.5
>>> 1/2.
0.5
>>> 1./2.
0.5
以上都是正确的写法,小数点后的0可以不写,但建议还是规范写法便于阅读。

2)设置Python除法的执行方式:
>>> from __future__ import division
>>> 1/2
0.5
或 -Qnew 的方式启动Python:
C:\Users\yangliehui>python -Qnew
Python 2.7.13 (v2.7.13:a06454b1afa1, Dec 17 2016, 20:53:40) [MSC v.1500 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> 1/2
0.5

      在以上两种方式下除号“/”不能实现截取小数点的整除了,但Python提供了一个可以在上述两种方式下实现截取小数并整除的方式——双斜杠: 
>>> 1/2
0.5
>>> 1//2
0
>>> 1.0//2.0
0.0
      可以看到,使用//,即使是浮点数1.0//2.0也实现了小数点的截取整除; 

      除了上面的几个运算之外,还有取余运算和幂运算,我们这里简单提及一下:
      取余运算——x%y
>>> 10 % 3
1

      幂运算——x ** y
>>> 2 ** 3
8
      表示2³。幂运算符的优先级高于取反符号,比如:
>>> -2 ** 2
-4
>>> (-2) ** 2
4
四、长整数
      当我们在写一个整数的时候,Python默认会认为是int类型整数,比如:
>>> 1000
1000
但是,当数字特别大,大到超过int类型的最大长度时,Python就会自动帮我们转为long型。int与long型的具体区别在后面的课程中还会深入的涉及到,这里我们只需要知道,整数类型有int和long,当整数超过int规定的最大长度时就必须要用long类型表示。那么这个int的最大值是多大呢?我们可以用下面的代码查一下:
>>> import sys
>>> print sys.maxint
2147483647
2147483647就是int的最大值(正好是:2 ^ 31 - 1 = 2147483647),超过这个最大值,Python就会自动帮我们转换为long类型:
>>> 2147483647
2147483647
>>> 2147483648
2147483648L
>>> 2147483647 + 1
2147483648L
我们看到当整数大于2147483647后,Python输出的整数后面加上了“L”。这里,我们说整数被被动的转换为了long型了,那么我们可不可以主动直接定义一个long型整数呢?看下面的例子:
>>> 100l
100L
>>> 100L
100L
>>> 100L * 3
300L
从上面的例子看,我们可以主动定义一个long型整数,即使它没有超过int的最大限度,同时long型整数可以参与计算。这里我们需要注意的是,定义long型整数时,在数字后面可以加“l”(小写的L)或“L”都可以,但是小写的L(“l”)更像数字1,为了便于阅读,我们这里强烈建议在定义时用大写的L。

五、Python中的进制
      0x开头的16进制:
>>> 0xF
15
      0开头的8进制:
>>> 010
8
      这里重点注意的是,当我们在赋值时,一定要注意,比如 v  = 010,不要误以为010就等于十进制的10或误认为010是一种错误的写法。数字前面多加一个0意思就完全变了。
六、变量的定义及赋值

>>> x = 2
>>> x * 5
10
上面的例子中,定义了一个变量x,并将int类型2,赋值给了x,切记不是x等于2的意思。
>>> input("The meaning of life:")
The meaning of life:42
42
input函数获取用户的输入值。当用户输入42后,回车,立即输出了输入值42。在上面的例子中我们只能输入数字类型,如果输入了非数字类型,就会报错:

>>> input("The meaning of life:")
The meaning of life:test
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name 'test' is not defined
后面在讲到input 与 raw_input 的区别的时候就会明白为什么。

>>> x = input("x=")
x=34
>>> y = input("y=")
y=56
>>> print x * y
1904
除此之外,还可以根据输入的数字进行各种运算。


七、常用函数的初步了解

  • pow函数,幂运算
>>> 2**3
8
>>> pow(2,3)
8
>>>
实现幂运算可以用上面的两种形式,“**”符号已经在上面的例子中了解了基本用法,这里我们只重点关注pow函数。
pow函数分为Python自带函数和math模块函数,下面做一个对比: 
 Python自带 math模块 代码示例 
使用方式 直接pow使用 需要导入math模块,使用import math语句 Python自带: 
>>> pow(2,3)
8

math模块: 
>>> import math
>>> math.pow(2,3)
8.0
语法 
pow(x, y [,z])
z 可选项,表示结果对z取模,等价于:
x**y % z
math.pow(x,y) Python自带: 
>>> pow(2,3)
8
>>> 2**3
8

>>> pow(2,3,6)
2
>>> 2**3%6
2



math模块,发现math.pow并不支持取模的方式: 
>>> math.pow(2,3,6)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: pow expected 2 arguments, got 3
>>>
>>> math.pow(2,3)
8.0
结果不同点 当参数为整数时,返回的就是整数类型。当参数为float时,也能正常float类型返回。 管参数是否整数,返回的都是float类型。 Python自带: 
>>> pow(2,3)
8
>>> pow(2.1,2)
4.41



math模块,发现结果为8.0: 
>>> math.pow(2,3)
8.0
>>> math.pow(2.1,2)
4.41


  • abs函数,取绝对值 
      语法abs(x),即取x的绝对值。 
>>> abs(-100)
100
>>> abs(100)
100
>>> abs(-23.343)
23.343
>>> abs(2000L)
2000L
>>> abs(-2000L)
2000L

  • round函数,四舍五入 
语法:round(x [,n])。
x-要四舍五入的数值;
n-保留小数位数,如果不写默认保留整数,小数点后1位并且是0
>>> round(2.645,2)
2.65
>>> round(2.645)
3.0
注意:round函数存在的一些问题: 
一、round函数与Python的版本有关系,如下: 
Python2 
>>> round(0.5)
1.0
Python3 
>>> round(0.5)
0
上述的差异,我们看一下官方文档的说明:
Python2:
保留值将保留到离上一位更近的一端(四舍六入),如果距离两端一样远,则保留到离0远的一边。所以round(0.5)会近似到1,而round(-0.5)会近似到-1;
Python3:
如果距离两边一样远,会保留到偶数的一边。比如round(0.5)和round(-0.5)都会保留到0,而round(1.5)会保留到2;

二、round得到的结果未必是想要的,如下:
>>> round(2.675,2)
2.67
>>> round(2.375,2)
2.38
区别在于2.675舍掉了后面的5,而2.375是5入一位。怎么解释这种现象?
round(2.675, 2) 的结果,不论我们从python2还是3来看,结果都应该是2.68的,结果它偏偏是2.67,为什么?这跟浮点数的精度有关。我们知道在机器中浮点数不一定能精确表达,因为换算成一串1和0后可能是无限位数的,机器已经做出了截断处理。那么在机器中保存的2.675这个数字就比实际数字要小那么一点点。这一点点就导致了它离2.67要更近一点点,所以保留两位小数时就近似到了2.67。


  • floor(x)函数,返回小于或等于x的最大整数(向下取整) 
语法floor(x)
该函数无法直接使用,需要import math。
>>> import math
>>> math.floor(-47.34)
-48.0
>>> math.floor(100.99)
100.0
>>> math.floor(1000L)
1000.0
>>> math.floor(math.pi)
3.0
返回小于或等于x的最大整数,即向下取整。

  • ceil(x)函数,返回大于或等于x的最小整数(向上取整) 
语法ceil(x)
ceil与floor是相对的,所有同样需要import math。
>>> import math
>>> math.ceil(-47.34)
-47.0
>>> math.ceil(100.01)
101.0
>>> math.ceil(1000L)
1000.0
>>> math.ceil(math.pi)
4.0
返回大于或等于x的最小整数(向上取整)。

在上述例子中floor和ceil返回的都是float类型,如果想得到int类型,可以使用int类型进行类型转换: 
>>> int (math.floor(32.9))
32
>>> int (math.ceil(32.9))
33
同理,对于类型转换,除了int(object)外,还有float(object)、long(object)
int() 和 long() 在参数为字符串时,字符串内必须是int或long的样式,如果出现小数点就会报错,如下:
>>> int(12.9)
12
>>> int("12")
12
>>> int("12.9")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '12.9'
>>>
>>> int("a")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'a'

>>> long(100)
100L
>>> long(100.99)
100L
>>> long("100")
100L
>>> long("100.99")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for long() with base 10: '100.99'
>>> long(100L)
100L
>>> long("a")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for long() with base 10: 'a'
>>> long("100L")
100L

>>> float(12)
12.0
>>> float(12.45)
12.45
>>> float("12")
12.0
>>> float("12.45")
12.45
>>> float("a")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: could not convert string to float: a

  • sqrt函数,返回平方根 
语法:sqrt(x)
该函数同样不能直接使用,需要import math模块。
>>> import math
>>> math.sqrt(9)
3.0
>>> math.sqrt(0)
0.0
>>> math.sqrt(-9)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: math domain error
可以看到x的值必须大于等于0。且返回的是float类型。
当x小于0的时候,程序报错了,但负数是用平方根的,负数的平方根是虚数。这是如果要计算负数的平方根需要导入cmath(complex math)模块。
>>> import cmath
>>> cmath.sqrt(-9)
3j
面的3j就是虚数。另外Python本身自带了对复数计算的支持,但并没有单独的虚数类型,他们被看做实数部分为0的复数。 
>>> 3j*3
9j


八、导入模块

在以上的例子中,我们已经用到了import这种语句,称为“导入模块
语句:import 模块名
比如:
>>> import math
>>> math.pow(2,3)
8.0
另一种导入的语句格式为“from 模块名 import 函数”。这种导入的模块的方式好处是在使用函数时不用“模块名.函数名”了,直接使用函数即可: 

>>> from math import sqrt
>>> sqrt(9)
3.0

这种使用的缺点是,如果两个不同的模块中有相同的函数名,则后面导入的函数会把前面导入的函数覆盖掉。
比如,math模块的sqrt和cmath的sqrt函数:
>>> from math import sqrt
>>> from cmath import sqrt
>>> sqrt(9)
(3+0j)
>>>
>>> from cmath import sqrt
>>> from math import sqrt
>>> sqrt(9)
3.0


我们也可以把函数赋给一个变量 :

>>> import math
>>> foo = math.sqrt
>>> foo(9)
3.0


九、Python脚本的运行

在以上的例子中,都是使用交互式方式写的代码片。我们也可以写到脚本文件中,脚本文件.py后缀名结尾; 

命令提示符运行脚本:
Window系统
C:\Users\yangliehui>python hello.py
或Linux系统 

$python hello.py
当然了,前提是要配置环境变量,如果不想配置环境变量,也可以在Python安装目录下执行脚本。

十、Python中的注释

“#”号注释符

>>> #这一行是注释
... print "hello"
hello
#号后面的内容Python会忽略。

十一、字符串初步了解

字符串的详细内容,会在后面的内容中占用一整章节来学习,现在只做一些初步的了解。

>>> "hello World"
'hello World'
>>> 'hello World'
'hello World'
在上面的字符串中,发现单引号和双引号是一样的,在交互式方式下,都打印出了'hello World'。

>>> "Let's go!"
"Let's go!"
>>> '"Hello World!" she said'
'"Hello World!" she said'
单引号与双引号的两种使用方式,可以满足字符串中出现单引号和双引号的情形。如果不用这种方式,还可以使用反斜线转义。 


>>> 'Let\'s go!'
"Let's go!"
>>> "\"Hello World!\" she said"
'"Hello World!" she said'
反斜线转义。


>>> "Let's say" '"Hello World!"'
'Let\'s say"Hello World!"'

一个字符串接一个字符串的方式可以拼接成一个新的字符串,单引号字符串和双引号字符串可以混合使用,如上例。
这种方式只在同时写两个字符串的情况下才有效,下面的方式并不能拼接:
>>> x = "Hello"
>>> y = "World!"
>>> x y
  File "<stdin>", line 1
    x y
      ^
SyntaxError: invalid syntax

但是一般的拼接字符串还是用以下方式:
“+”号拼接
>>> "Let's say"  +  '"Hello World!"'
'Let\'s say"Hello World!"'
>>>
>>> x = "Hello"
>>> y = "World!"
>>> x + y
'HelloWorld!'


注意:字符串表示:str和repr 
先来看一段程序: 

>>> "Hello World!"
'Hello World!'
>>>
>>> print "Hello World!"
Hello World!
两种方式下打印的Hello World!并不一样,上面的带引号,下面的不带引号。

带引号的输出值会保持其在Python代码中的状态;

而不带引号的输出是希望用户所看到的状态;

为了印证上面的区别,看下面代码: 

>>> "Hello World!"
'Hello World!'
>>> 10000L
10000L
>>>
>>> print "Hello World!"
Hello World!
>>> print 10000L
10000
我们看到'Hello World!' 和 10000L是其在代码中的状态值; 

而Hello World!和 10000是显示给用户看到的; 

面这两种不同的输出字符串的方式,我们可以使用函数来实现: 

>>> print repr("Hello World!")
'Hello World!'
>>> print repr(10000L)
10000L
>>>
>>> print str("Hello World!")
Hello World!
>>> print str(10000L)
10000
我们可以看到: 

repr函数输出会保持其在Python代码中的状态;

str函数输出是希望用户所看到的状态;


repr(x)函数等价于`x`(x为数字的情况下成立) 

>>> print "Hello" + 32
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects
>>>
>>>
>>> print "Hello" + `32`
Hello32
>>>
>>>
>>> print "Hello" + repr(32)
Hello32
>>> print "Hello" + str(32)
Hello32
字符串直接拼接数字是不行的。可以使用下面的三种方式,注意反引号“`”,可以把32转换为字符串方式,而且等价repr函数。 


总结:str,repr、反引号是将Python值转换为字符串的三种方式: 

str让字符串更易于阅读; 

repr(和反引号)把字符串转换为合法的Python的表达式; 


长字符串的了解:

>>> print '''This is a very long
... string '''
This is a very long
string
>>>
>>> print """This is a very long
... string """
This is a very long
string
这种字符串支持多行。而且由于三个引号的特殊性,字符串中间出现的单引号或双引号就不需要再转义了。 
除了三个引号可以使字符串换行以外,还可以使用反斜线,如下: 

>>> print "Hello \
... World!"
Hello World!
>>> 1+2\
... +3
6
>>> print \
... "Hello World!"
Hello World!


原始字符串: 
看一段代码: 

>>> print "C:\name"
面的代码我们预期输出C:\name,可实际输出的是这样的: 

>>> print "C:\name"
C:
ame
出现上面问题的原因是\n转义符换行的意思,因此在“:”后换行了,并且输出了ame。避免出现类似情况的方法是对“\”进行转移。 

>>> print "C:\\name"
C:\name
看起来没有问题,但是当路径很长的时候就显得不那么方便了,因此还有方式就是使用原始字符串。 

>>> print r"C:\name"
C:\name

r开头的原始字符串如上所示。它会原样输出字符串的内容。
上面的代码原始字符串中“\”反斜线不能出现在最后,如:
>>> print r"C:\name\"
  File "<stdin>", line 1
    print r"C:\name\"
                    ^
SyntaxError: EOL while scanning string literal
这是显而易见的,后面加的反斜线把后面的引号转义了。如果非要在后面加上反斜线可以把反斜线转义了。 

>>> #结尾会出现两个反斜线
... print r"C:\name\\"
C:\name\\
>>> #如果只想结尾出现一个反斜线
... print r"C:\name" + "\\"
C:\name\

十二、input 与 raw_input 的区别 

先看一下例子: 

>>> name = input("What's your name ?\r\n")
What's your name ?
yangliehui
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name 'yangliehui' is not defined
使用input函数时当输入名字后程序报错了。原因是input会认为用户输入的是合法的Python表达式,和下面的这行代码没什么区别
>>> yangliehui
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'yangliehui' is not defined


因此下面的写法就不会报错: 

>>> name = input("What's your name ?\r\n")
What's your name ?
"yangliehui"
>>> print name
yangliehui
因为这种写法等价于:

>>> print "yangliehui"
yangliehui

再来看一下raw_input: 

>>> name = raw_input("What's your name?\r\n")
What's your name?
yangliehui
>>> name
'yangliehui'
>>>
>>> age = raw_input("How old are you?\r\n")
How old are you?
30
>>> age
'30'
>>>
我们看到使用raw_input时不用在加引号,因为raw_input会把所有的输入当做原始数据(raw data)然后放入字符串中。我们可以看到输出值都是字符串。 


十三、获得帮助

要善用help()函数获得帮助。








  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值