当前位置:   article > 正文

【python】Python速成(一)--基础语法_python语法速成

python语法速成

摘自:点击打开链接

基础语法

Python的语法比较简单,采用缩进方式,写出来的代码就像下面的样子:

  1. # print absolute value of an integer:
  2. a = 100
  3. if a >= 0:
  4. print(a)
  5. else:
  6. print(-a)

#开头的语句是注释,注释是给人看的,可以是任意内容,解释器会忽略掉注释。其他每一行都是一个语句,当语句以冒号:结尾时,缩进的语句视为代码块。

缩进有利有弊。好处是强迫你写出格式化的代码,但没有规定缩进是几个空格还是Tab。按照约定俗成的管理,应该始终坚持使用4个空格的缩进。

缩进的另一个好处是强迫你写出缩进较少的代码,你会倾向于把一段很长的代码拆分成若干函数,从而得到缩进较少的代码。

缩进的坏处就是“复制-粘贴”功能失效了,这是最坑爹的地方。当你重构代码时,粘贴过去的代码必须重新检查缩进是否正确。此外,IDE很难像格式化Java代码那样格式化Python代码。

最后,请务必注意,Python程序是大小写敏感的,如果写错了大小写,程序会报错。

list

Python内置的一种数据类型是列表:list。list是一种有序的集合,可以随时添加和删除其中的元素。

比如,列出班里所有同学的名字,就可以用一个list表示:

  1. >>> classmates = ['Michael', 'Bob', 'Tracy']
  2. >>> classmates
  3. ['Michael', 'Bob', 'Tracy']

变量classmates就是一个list。用len()函数可以获得list元素的个数:

  1. >>> len(classmates)
  2. 3

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

  1. >>> classmates[0]
  2. 'Michael'
  3. >>> classmates[1]
  4. 'Bob'
  5. >>> classmates[2]
  6. 'Tracy'
  7. >>> classmates[3]
  8. Traceback (most recent call last):
  9. File "<stdin>", line 1, in <module>
  10. IndexError: list index out of range

当索引超出了范围时,Python会报一个IndexError错误,所以,要确保索引不要越界,记得最后一个元素的索引是len(classmates) - 1

如果要取最后一个元素,除了计算索引位置外,还可以用-1做索引,直接获取最后一个元素:

  1. >>> classmates[-1]
  2. 'Tracy'

tuple

另一种有序列表叫元组:tuple。tuple和list非常类似,但是tuple一旦初始化就不能修改,比如同样是列出同学的名字:

>>> classmates = ('Michael', 'Bob', 'Tracy')

现在,classmates这个tuple不能变了,它也没有append(),insert()这样的方法。其他获取元素的方法和list是一样的,你可以正常地使用classmates[0]classmates[-1],但不能赋值成另外的元素。

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

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

  1. >>> t = (1, 2)
  2. >>> t
  3. (1, 2)

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

  1. >>> t = ()
  2. >>> t
  3. ()

但是,要定义一个只有1个元素的tuple,如果你这么定义:

  1. >>> t = (1)
  2. >>> t
  3. 1

定义的不是tuple,是1这个数!这是因为括号()既可以表示tuple,又可以表示数学公式中的小括号,这就产生了歧义,因此,Python规定,这种情况下,按小括号进行计算,计算结果自然是1

所以,只有1个元素的tuple定义时必须加一个逗号,,来消除歧义:

  1. >>> t = (1,)
  2. >>> t
  3. (1,)

Python在显示只有1个元素的tuple时,也会加一个逗号,,以免你误解成数学计算意义上的括号。

条件判断

计算机之所以能做很多自动化的任务,因为它可以自己做条件判断。

比如,输入用户年龄,根据年龄打印不同的内容,在Python程序中,用if语句实现:

  1. age = 20
  2. if age >= 18:
  3. print('your age is', age)
  4. print('adult')

根据Python的缩进规则,如果if语句判断是True,就把缩进的两行print语句执行了,否则,什么也不做。

也可以给if添加一个else语句,意思是,如果if判断是False,不要执行if的内容,去把else执行了:

  1. age = 3
  2. if age >= 18:
  3. print('your age is', age)
  4. print('adult')
  5. else:
  6. print('your age is', age)
  7. print('teenager')

注意不要少写了冒号:


循环

要计算1+2+3,我们可以直接写表达式:

  1. >>> 1 + 2 + 3
  2. 6

要计算1+2+3+...+10,勉强也能写出来。

但是,要计算1+2+3+...+10000,直接写表达式就不可能了。

为了让计算机能计算成千上万次的重复运算,我们就需要循环语句。

Python的循环有两种,一种是for...in循环,依次把list或tuple中的每个元素迭代出来,看例子:

  1. names = ['Michael', 'Bob', 'Tracy']
  2. for name in names:
  3. print(name)

执行这段代码,会依次打印names的每一个元素:

  1. Michael
  2. Bob
  3. Tracy

所以for x in ...循环就是把每个元素代入变量x,然后执行缩进块的语句。

再比如我们想计算1-10的整数之和,可以用一个sum变量做累加:

  1. sum = 0
  2. for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
  3. sum = sum + x
  4. print(sum)

如果要计算1-100的整数之和,从1写到100有点困难,幸好Python提供一个range()函数,可以生成一个整数序列,再通过list()函数可以转换为list。比如range(5)生成的序列是从0开始小于5的整数:

  1. >>> list(range(5))
  2. [0, 1, 2, 3, 4]

range(101)就可以生成0-100的整数序列,计算如下:

  1. sum = 0
  2. for x in range(101):
  3. sum = sum + x
  4. print(sum)

请自行运行上述代码,看看结果是不是当年高斯同学心算出的5050。


dict

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

举个例子,假设要根据同学的名字查找对应的成绩,如果用list实现,需要两个list:

  1. names = ['Michael', 'Bob', 'Tracy']
  2. scores = [95, 75, 85]

给定一个名字,要查找对应的成绩,就先要在names中找到对应的位置,再从scores取出对应的成绩,list越长,耗时越长。

如果用dict实现,只需要一个“名字”-“成绩”的对照表,直接根据名字查找成绩,无论这个表有多大,查找速度都不会变慢。用Python写一个dict如下:

  1. >>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
  2. >>> d['Michael']
  3. 95

第二种方法是先在字典的索引表里(比如部首表)查这个字对应的页码,然后直接翻到该页,找到这个字。无论找哪个字,这种查找速度都非常快,不会随着字典大小的增加而变慢。

dict就是第二种实现方式,给定一个名字,比如'Michael',dict在内部就可以直接计算出Michael对应的存放成绩的“页码”,也就是95这个数字存放的内存地址,直接取出来,所以速度非常快。

你可以猜到,这种key-value存储方式,在放进去的时候,必须根据key算出value的存放位置,这样,取的时候才能根据key直接拿到value。

把数据放入dict的方法,除了初始化时指定外,还可以通过key放入:

  1. >>> d['Adam'] = 67
  2. >>> d['Adam']
  3. 67

由于一个key只能对应一个value,所以,多次对一个key放入value,后面的值会把前面的值冲掉:

  1. >>> d['Jack'] = 90
  2. >>> d['Jack']
  3. 90
  4. >>> d['Jack'] = 88
  5. >>> d['Jack']
  6. 88

如果key不存在,dict就会报错:

  1. >>> d['Thomas']
  2. Traceback (most recent call last):
  3. File "<stdin>", line 1, in <module>
  4. KeyError: 'Thomas'

要避免key不存在的错误,有两种办法,一是通过in判断key是否存在:

  1. >>> 'Thomas' in d
  2. False

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

  1. >>> d.get('Thomas')
  2. >>> d.get('Thomas', -1)
  3. -1

注意:返回None的时候Python的交互式命令行不显示结果。

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

  1. >>> d.pop('Bob')
  2. 75
  3. >>> d
  4. {'Michael': 95, 'Tracy': 85}

请务必注意,dict内部存放的顺序和key放入的顺序是没有关系的。


set

set和dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中,没有重复的key。

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

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

注意,传入的参数[1, 2, 3]是一个list,而显示的{1, 2, 3}只是告诉你这个set内部有1,2,3这3个元素,显示的顺序也不表示set是有序的。。

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

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

通过add(key)方法可以添加元素到set中,可以重复添加,但不会有效果:

  1. >>> s.add(4)
  2. >>> s
  3. {1, 2, 3, 4}
  4. >>> s.add(4)
  5. >>> s
  6. {1, 2, 3, 4}

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

  1. >>> s.remove(4)
  2. >>> s
  3. {1, 2, 3}

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

  1. >>> s1 = set([1, 2, 3])
  2. >>> s2 = set([2, 3, 4])
  3. >>> s1 & s2
  4. {2, 3}
  5. >>> s1 | s2
  6. {1, 2, 3, 4}

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



本文内容由网友自发贡献,转载请注明出处:https://www.wpsshop.cn/w/很楠不爱3/article/detail/728941
推荐阅读
相关标签
  

闽ICP备14008679号