Python 30分钟入门——数据类型and控制结构

Python是一门脚本语言,我也久闻大名,但正真系统的接触学习是在去年(2013)年底到今年(2014)年初的时候。不得不说的是Python的官方文档相当齐全,如果你是在Windows上学习Python,安装包自带的“Python Manuals”就是一份很好的学习资料(基本上不用去找其他资料了);尤其是其中的Tutorial,非常适合初学者。本文一方面总结了python语言的核心——数据类型和控制结构;另一方面,通过与其他语言的对比表达了我对Python的一些拙见。

数据类型

Python简洁的背后是因为有着强大的类型系统的支持。Python世界的基本数据类型有{int, long, float, complex, str, list, set, tuple, dict},下面通过Python解释器在交互模式下的输入输出实例进行演示(其中有前导符>>>或...的是输入):
tips: Python世界里,可以用type(x)来输出x的类型.

int, long, float, str, complex

>>> type(123)
<type 'int'>
>>> type(-234)
<type 'int'>
>>> type(123456123456)
<type 'long'>
>>> type(-123456123456)
<type 'long'>
>>> type(123.456)
<type 'float'>
>>> type('abc')
<type 'str'>
>>> type("hello, world")
<type 'str'>
从最后两次输入可以看到Python的字符串可以用单引号也可以用双引号。另外,大家可能会疑惑的是到底多大是int和多大是long呢?下面我们来一探究竟:
>>> type(123456)
<type 'int'>
>>> type(123456789)
<type 'int'>
>>> type(1234567890)
<type 'int'>
>>> type(12345678901)
<type 'long'>
可以看到1234567890还是int,12345678901就是long了,说明int是有范围的。记得C/C++的int长度(4B)的同学都知道,C/C++里int的取值范围是:[-2^31, 2^31-1]也就是[-2147483648, 2147483647]。据此,我们可以看看Python的int范围:
>>> type(2147483647)
<type 'int'>
>>> type(2147483648)
<type 'long'>
>>> type(-2147483648)
<type 'int'>
>>> type(-2147483649)
<type 'long'>
这次试验说明,Python的int范围和C/C++一样。
那么,如果我想指定一个比较小的long怎么办呢?可以通过加L(或小写l)后缀:
>>> type(1L)
<type 'long'>
>>> type(2l)
<type 'long'>
另外,Python的浮点数是没有double的:
>>> type(123.456)
<type 'float'>
>>> type(123456123456.123456123456123456123456)
<type 'float'>

complex(复数)
复数类型在很多语言中是没有的,Python通过整数加J(或小写j)后缀表示复数:
>>> type(3+4j)
<type 'complex'>
>>> type(3+4J)
<type 'complex'>
>>> type(4j)
<type 'complex'>
>>> type(j)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'j' is not defined
>>> type(1j)
<type 'complex'>
但是1j不允许直接写成j,j会被当做name查找,如果没找到就会报错。

list, set, tuple, dict

list, tuple, dict分别是列表、元组、字典(有的语言叫映射map)。这些类型才是Python类型系统的过人之处,在多数编译型语言(C、C++、Java、C#等)中,这些类型都要通过库来提供(如C++、Java、C#),有的或许库也没有提供(如C)。
>>> type([1, 2, 3])
<type 'list'>
>>> type({2, 3, 4})
<type 'set'>
>>> type((3, 4, 5))
<type 'tuple'>
>>> type({'key1': 'value1', 'key2': 'value2'})
<type 'dict'>
可以看到(), [], {}和它括起来的一系列元素,分别是表示:元组、列表、集合。而dict则是{key1: value1, [key2: value2, ...]}的形式。
上面列出的各种集合的元素类型一致,这在编译型语言里通常是必须的,但在Python里不必:
>>> (1, 'two', 3.0)
(1, 'two', 3.0)
>>> [(1, 'two', 3.0), '4', 5]
[(1, 'two', 3.0), '4', 5]
>>> {1, 2L, 3.0, 4j}
set([1, 2L, 3.0, 4j])
>>> {1: 'one', 'one': 1}
{1: 'one', 'one': 1}

控制结构

结构化程序设计方法提出之时,就有前辈证明了任何算法都可以使用:顺序、选择、循环三种结构表达。下面将展示Python的基本语法,以及选择和循环。

顺序结构

顺序结构本身没什么好说的,这里介绍一下Python的其他特性。

语句

Python的语句以换行符结尾(不像C家族的分号结尾):
>>> print "hello, world"
hello, world
并且Python程序没有所谓的“入口”,这和多数脚本语言类似。

弱类型

Python是弱类型的,也就是变量的类型不是一成不变的。这也和很多脚本语言类似。
>>> a = 123
>>> b = "asdf"
>>> c = [3, 4, 5]
>>> a
123
>>> b
'asdf'
>>> c
[3, 4, 5]
>>> a = b
>>> b
'asdf'
这段交互中有两点与C语言(C++等)不同:
  1. 使用变量前不用向提前声明变量的类型
  2. 一个变量初始化为一个类型后还能给他赋其他类型的值
提示:在Python解释器的交互模式下直接输入变量名也能显示变量的值
“变量”一词在Python里应该叫“名字”(或者符号)更确切,在Python中你可以给一个符号赋予任何类型的值。稍后你将会看到可以给原本赋值为int的对象赋值为一个函数,一个类。

函数

Python的函数定义以def开始,如果有返回值需要用return传递返回值。
比如如下代码定义了一个名为sayHello的函数,并用‘Jack‘为参数进行了一次调用:
def sayHello(name):
	print 'Hello, ' + name + '!'
	
sayHello('Jack')
这段代码的运行结果为:Hello, Jack!
(可将这段代码保存为sayHello.py,然后在对应目录运行python sayHello.py)

Python的类定义以class开始,属性可以在class下方声明也可以在__init__方法里通过self.xxx隐式声明。
先来一段最简单的关于类的代码:
class Man:	
	def __init__(self, name):
		self.name = name
	
	def hello(self):
		print 'Hello, ' + self.name + '!'

m = Man('Jack')
m.hello()
这段代码也会输出:Hello, Jack!
tips: Python方法的第一个参数必须是名为self的参数,用于操作对象的成员。__init__类似其他语言的”构造方法“。
类的更多特性和OOP有关,以后有时间再单独发一篇博文展示。

顺便看看函数、类以及类的实例在Python解释器眼中都是什么:
>>> type(sayHello)
<type 'function'>
>>> type(Man)
<type 'classobj'>
>>> type(m)
<type 'instance'>
>>> type(m.hello)
<type 'instancemethod'>
>>> type(Man.hello)
<type 'instancemethod'>
可以想象,Python世界里的东西都是”灰色“的,解释器对它们”一视同仁“,从来不以貌取人,只看他们现在身上的标签是什么~

选择结构

Python的选择结构以if开始。

bool

if必然要涉及bool值,Python bool的取值为True和False:
>>> type(1==1)
<type 'bool'>
>>> type(True)
<type 'bool'>
>>> type(False)
<type 'bool'>
(上面好像忘了列出bool类型)

对于Number(int, long, float, complex),0在if条件上也是False:
>>> if 1:
...     print "true"
...
true
>>> if 0:
...     print "true"
... else:
...     print "false"
...
false
>>> if 0.0:
...     print "0.0 is true"
...
>>> if 0j:
...     print "0j is true"
...
提示:Python是以代码缩进区分代码块的
除此之外,空的string和空的集合(tuple, list, set)也是False:
>>> if '':
...     print 'null string is true'
...
>>> if ():
...     print 'null tuple is true'
...
>>> if []:
...     print 'null list is true'
...
>>> if {}:
...     print 'null set is true'
...

if, if-else & if-elif-else

上面几个if示例多是只有一个分支的,当然Python也支持多个分支的if:
>>> x = int(raw_input("Please enter an integer: "))
Please enter an integer: 42
>>> if x < 0:
...      x = 0
...      print 'Negative changed to zero'
... elif x == 0:
...      print 'Zero'
... elif x == 1:
...      print 'Single'
... else:
...      print 'More'
...
More

循环结构

Python的循环有for和while两种,没有do-while,也没有loop-until。

for

Python的for循环和C的不同,它更像C++,Java里的新式for循环:
>>> a = [1, 'two', 3.0]
>>> for i in a:
...     print i
...
1
two
3.0
这种for迭代集合很方便。

但是要想像典型C语言的for循环那样迭代一个整数区间怎么办?别怕,Python提供了内置(built-in)函数range(),它能返回整数区间列表,供你迭代,用起来也很方便:
>>> for i in range(1, 6):
...     print i
...
1
2
3
4
5
>>> for i in range(10, 65, 10):
...     print i
...
10
20
30
40
50
60
这里展示了range的两种调用形式,一种是range(a, b),它将返回一个从a(包含a)到b(不包含)的整数列表(list),另一种range(a, b, s),将返回一个a~b,以s为步长的list:
>>> range(1, 6)
[1, 2, 3, 4, 5]
>>> range(10, 65, 10)
[10, 20, 30, 40, 50, 60]

while

Python的while循环和C的while差不多:
>>> i = 1
>>>
>>> while i < 5:
...     i = i+1
...     print i
...
2
3
4
5

顺便一提,Python里 i=i+1 不能写成i++,Python不支持这种语法;但可以写成 i += 1:
>>> i
5
>>> i += 1
>>> i
6
>>> i++
  File "<stdin>", line 1
    i++
      ^
SyntaxError: invalid syntax
>>> ++i
6
>>> i
6
各位可能会疑惑,为什么++i可以?因为pyhon支持前置的+(正负号)运算,++被当做两次正运算了;同理,+++i,++++i都是一样的;我们可以顺便测一下负号运算:
>>> i
6
>>> +++i
6
>>> ++++i
6
>>> -i
-6
>>> --i
6
>>> ---i
-6
和想象的结果一致,Great!

输入输出(IO)

当你想动手写点”更有意思“的小程序的时候,你会发现除了三大基本控制结构和数据类型之外,你最需要的可能就是IO功能。
Q: 输出可以用print,那么输入呢?是input吗?
A:input可以,但更多时候需要用的可能是raw_input和readline这两个built-in function,但readline仅适用于Unix平台.
Q:那么input和raw_input有什么区别呢?
A:来看看我和解释器的下面这段交互,看看你能不能自己发现它们的不同。
>>> varA = raw_input('please input:')
please input:Life is too short, you need Python!
>>> varA
'Life is too short, you need Python!'
>>> type(raw_input('input something:'))
input something:asdf
<type 'str'>
>>> type(raw_input('input something:'))
input something:123
<type 'str'>
A:你看到了,raw_input不论你输入什么都会返回str类型,这也是为什么叫做raw_input的原因。
A: 继续往下,你会看到input:
>>> type(input('input sth:'))
input sth:123
<type 'int'>
>>> type(input('input sth:'))
input sth:asdf
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name 'asdf' is not defined
>>> type(input('input sth:'))
input sth:varA
<type 'str'>
>>> input('sth:')
sth:varA
'Life is too short, you need Python!'
>>> input('try some input like your code:')
try some input like your code:[1, 'two', 3.0]
[1, 'two', 3.0]
>>> input('try again:')
try again:'Oh!!!'
'Oh!!!'
Q: Oh, I know! input会按代码的形式解释输入!
A: 嗯,你提到了”解释“,看来你已经悟出了Python的真谛,你可以下山了!
Q: Master, 这样就可以了么?我知道的好像太少了吧?
A: 为师这里有一本《Python秘籍》,你拿去吧,所有问题你都能找到答案,但答案未必在这本书里
(徒儿A就此辞别师父Q,开始了他的Python之旅)

后记(我的拙见)

Python是解释型语言,它的内置集合类型非常强大!作为一个学了几门C家族语言(C、C++、Java、C#)的我来说,tuple,list,set,dict都是内置类型,简直是太美好了!
在我看来:
1.由于有语言级的tuple, list, set, dict,Python非常适合用来写算法,而且Python写出的算法必然要比其他语言简洁得多!
2.Python的语法简洁易懂,默认提供了文件管理等功能,可以替代多数其他脚本的工作。
3.Python的弱类型(约束少)以及解释器交互模式的趣味性和便捷性,非常适合作为”第一门程序设计语言“,教授少年儿童。

郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。