Python快速入门（上）

西西弗没有斯

已于 2022-10-08 08:19:54 修改

阅读量594

点赞数

分类专栏：脚本语言文章标签： python 开发语言

于 2022-10-01 18:33:59 首次发布

本文链接：https://blog.csdn.net/Sisyphus415/article/details/127134251

版权

脚本语言专栏收录该内容

3 篇文章 1 订阅

订阅专栏

每次要用python写脚本的时候又得回去查书，很麻烦，所以把一些基础的东西整理成博客方便查阅。

一、变量

字符串

在python中，被双引号包括的字符串和被单引号括起的字符串其工作机制完全相同。
可以通过使用三个引号 “”" 或 ‘’’ 来指定多行字符串。如：

'''This is a short talk.
"What's your name?," I asked.
He said "Bond, James Bond."
'''

一个字符串可以使用某些特定的格式（Specification），随后， format 方法将被调用，使用这一方法中与之相应的参数替换这些格式。如：

age = 20
name = 'Swaroop'
print('{0} was {1} years old when he wrote this book'.format(name, age))
print('Why is {0} playing with that python?'.format(name))
#输出
#Swaroop was 20 years old when he wrote this book
#Why is Swaroop playing with that python?

Python 从 0 开始计数，这意味着索引中的第一位是 0，第二位是1，以此类推。
数字只是一个可选选项，所以同样可以写成：

age = 20
name = 'Swaroop'
print('{} was {} years old when he wrote this book'.format(name, age))
print('Why is {} playing with that python?'.format(name))

Python 中 format 方法所做的事情便是将每个参数值替换至格式所在的位置。这之中可以有更详细的格式，例如：

# 对于浮点数 '0.333' 保留小数点(.)后三位
print('{0:.3f}'.format(1.0/3))
# 使用下划线填充文本，并保持文字处于中间位置
# 使用 (^) 定义 '___hello___'字符串长度为 11
print('{0:_^11}'.format('hello'))
# 基于关键词输出 'Swaroop wrote A Byte of Python'
print('{name} wrote {book}'.format(name='Swaroop', book='A Byte of Python'))
#输出
#0.333
#___hello___
#Swaroop wrote A Byte of Python

标识符命名

在命名标识符时，需要遵守以下规则：

第一个字符必须是字母表中的字母（大写 ASCII 字符或小写 ASCII 字符或 Unicode 字符）或下划线（ _ ）。
标识符的其它部分可以由字符（大写 ASCII 字符或小写 ASCII 字符或 Unicode 字符）、下划线（ _ ）、数字（0~9）组成。
标识符名称区分大小写。例如， myname 和 myName 并不等同。要注意到前者是小写字母 n 而后者是大写字母 N 。
有效的标识符名称可以是 i 或 name_2_3 ，无效的标识符名称可能是2things ， this is spaced out ， my-name 和 >a1b2_c3 。

二、运算表达式

运算符

运算符	作用	例子
+（加）	两个对象相加。	3+5 则输出 8 。 ‘a’ + ‘b’ 则输出 ‘ab’ 。
-（减）	从一个数中减去另一个数，如果第一个操作数不存在，则假定为零。	-5.2 将输出一个负数， 50 - 24 输出 26 。
* （乘）	给出两个数的乘积，或返回字符串重复指定次数后的结果。	2 * 3 输出 6 。 ‘la’ * 3 输出 ‘lalala’ 。
** （乘方）	返回 x 的 y 次方。	3 ** 4 输出 81 （即 3 * 3 * 3 * 3 ）。
/ （除）	x 除以 y。	13 / 3 输出 4.333333333333333 。
// （整除）	x 除以 y 并对结果向下取整至最接近的整数。	13 // 3 输出 4 。-13 // 3 输出 -5 。
% （取模）	返回除法运算后的余数。	13 % 3 输出 1 。 -25.5 % 2.25 输出 1.5 。
<< （左移）	将数字的位向左移动指定的位数。（每个数字在内存中以二进制数表示，即 0 和1）	2 << 2 输出 8 。 2 用二进制数表示为 10 。向左移 2 位会得到 1000 这一结果，表示十进制中的 8 。
>> （右移）	将数字的位向右移动指定的位数。	11 >> 1 输出 5 。11 在二进制中表示为 1011 ，右移一位后输出 101 这一结果，表示十进制中的5 。
< （小于）	返回 x 是否小于 y。所有的比较运算符返回的结果均为 True 或 False 。	5 < 3 输出 False ， 3 < 6 输出 True 。比较可以任意组成组成链接： 3 < 5 < 7 返回 True 。
> （大于）	返回 x 是否大于 y。	5 > 3 返回 True 。如果两个操作数均为数字，它们首先将会被转换至一种共同的类型。否则，它将总是返回 False 。
<= （小于等于）	返回 x 是否小于或等于 y。	x = 3; y = 6; x<=y 返回 True 。
>= （大于等于）	返回 x 是否大于或等于 y。	x = 4; y = 3; x>=3 返回 True 。
== （等于）	比较两个对象是否相等。	x = 2; y = 2; x == y 返回 True 。x = ‘str’; y = ‘stR’; x == y 返回 False 。x = ‘str’; y = ‘str’; x == y 返回 True 。
!= （不等于）	比较两个对象是否不相等。	x = 2; y = 3; x != y 返回 True 。
not （布尔“非”）	如果 x 是 Ture ，则返回 False 。如果 x 是 False ，则返回 True 。	x = Ture; not x 返回 False 。
and （布尔“与”）	如果 x 是 False ，则 x and y 返回 False ，否则返回 y 的计算值。	当 x 是 False 时， x = False; y = True; x and y 将返回 False 。在这一情境中，Python 将不会计算 y，因为它已经了解 and 表达式的左侧是 False ，这意味着整个表达式都将是 False 而不会是别的值。这种情况被称作短路计算（Short-circuitEvaluation）。
or （布尔“或”）	如果 x 是 True ，则返回 True ，否则它将返回 y 的计算值。	x = Ture; y = False; x or y 将返回 Ture 。在这里短路计算同样适用。
对于数值运算，通常有如下的快捷表达方式：

a = a * 3
a *= 3

上述两种操作是相等的。

求值顺序

优先级由低到高：

lambda ：Lambda 表达式
if - else ：条件表达式
or ：布尔“或”
and ：布尔“与”
not x ：布尔“非”
in, not in, is, is not, <, <=, >, >=, !=, == ：比较，包括成员资格测试（Membership Tests）和身份测试（Identity Tests）。
| ：按位或
^ ：按位异或
& ：按位与
<<, >> ：移位
+, - ：加与减
*, /, //, % ：乘、除、整除、取余
+x, -x, ~x ：正、负、按位取反
** ：求幂
x[index], x[index:index], x(arguments…), x.attribute ：下标、切片、调用、属性引用
(expressions…), [expressions…], {key: value…}, {expressions…}：显示绑定或数组、显示列表、显示字典、显示设置

可以使用圆括号改变运算的顺序。

三、控制流

if

number = 23
guess = int(input('Enter an integer : '))
if guess == number:
	print('Congratulations, you guessed it.')
	print('(but you do not win any prizes!)')
elif guess < number:
	print('No, it is a little higher than that')
else:
	print('No, it is a little lower than that')
print('Done')
# 输出
#Enter an integer : 23
#Congratulations, you guessed it.
#(but you do not win any prizes!)
#Done

elif和else都是可选的，一个最小规模的if语句如下：

if True:
	print('Yes, it is true')

while

在条件为真的前提下重复执行某块语句。

number = 23
running = True
while running:
	guess = int(input('Enter an integer : '))
	if guess == number:
		print('Congratulations, you guessed it.')
		running = False
	elif guess < number:
		print('No, it is a little higher than that.')
	else:
		print('No, it is a little lower than that.')
else:
	print('The while loop is over.')
print('Done')
#输出
#Enter an integer : 23
#Congratulations, you guessed it.
#The while loop is over.
#Done

for循环

遍历序列中的每一个项目。

for i in range(1, 5):
	print(i)
else:
	print('The for loop is over')
#输出
#1
#2
#3
#4
#The for loop is over

range(1,5) 将输出序列 [1, 2, 3, 4] 。在默认情况下， range 将会以 1 逐步递增。如果我们向 range 提供第三个数字，则这个数字将成为逐步递增的加数。同样举个例子来说明， range(1,5,2) 将会输出 [1, 3] 。要记住这一序列扩展直到第二个数字，也就是说，它不会包括第二个数字在内。
range() 每次只会生成一个数字，如果希望获得完整的数字列表，要在使用 range() 时调用 list() 。例如下面这样： list(range(5)) ，它将会返回 [0, 1, 2, 3, 4] 。
for i in range(1,5) 等价于 for i in [1, 2, 3, 4] ，这个操作将依次将队列里的每个数字（或是对象）分配给 i ，一次一个，然后以每个 i 的值执行语句块。在本例中，我们这一语句块所做的就是打印出这些值。

break，continue

break 语句用以中断（Break）循环语句，也就是中止循环语句的执行，如果中断了一个 for 或 while 循环，任何相应循环中的else 块都将不会被执行。

while True:
	s = input('Enter something : ')
	if s == 'quit':
		break
	print('Length of the string is', len(s))
print('Done')
#输出
#Enter something : Programming is fun
#Length of the string is 18
#Enter something : When the work is done
#Length of the string is 21
#Enter something : quit
#Done

continue 语句用以告诉 Python 跳过当前循环块中的剩余语句，并继续该循环的下一次迭代。

while True:
	s = input('Enter something : ')
	if s == 'quit':
		break
	if len(s) < 3:
		print('Too small')
		continue
	print('Input is of sufficient length')
#输出
#Enter something : a
#Too small
#Enter something : abc
#Input is of sufficient length
#Enter something : quit

四、函数

函数可以通过关键字 def 来定义。这一关键字后跟一个函数的标识符名称，再跟一对圆括号，其中可以包括一些变量的名称，再以冒号结尾，结束这一行。随后而来的语句块是函数的一部分。

def say_hello():
	# 该块属于这一函数
	print('hello world')
# 函数结束
say_hello() # 调用函数
say_hello() # 再次调用函数
#输出
#hello world
#hello world

参数

def print_max(a, b):
	if a > b:
		print(a, 'is maximum')
	elif a == b:
		print(a, 'is equal to', b)
	else:
		print(b, 'is maximum')
# 直接传递字面值
print_max(3, 4)

x = 5
y = 7

# 以参数的形式传递变量
print_max(x, y)
#输出
#4 is maximum
#7 is maximum

第一次调用函数 print_max 时，我们以实参的形式直接向函数提供这一数字。在第二次调用时，我们将变量作为实参来调用函数。print_max(x, y) 将使得实参 x 的值将被赋值给形参a ，而实参 y 的值将被赋值给形参 b 。在两次调用中， print_max 都以相同的方式工作。

变量

当你在一个函数的定义中声明变量时，它们不会以任何方式与身处函数之外但具有相同名称的变量产生关系，也就是说，这些变量名只存在于函数这一局部（Local）。这被称为变量的作用域（Scope）。所有变量的作用域是它们被定义的块，从定义它们的名字的定义点始。

x = 50
def func(x):
	print('x is', x)
	x = 2
	print('Changed local x to', x)
	
func(x)
print('x is still', x)
#输出
#x is 50
#Changed local x to 2
#x is still 50

当我们第一次打印出存在于函数块的第一行的名为 x 的值时，Python 使用的是在函数声明之上的主代码块中声明的这一参数的值。
接着，我们将值 2 赋值给 x 。 x 是我们这一函数的局部变量。因此，当我们改变函数中x 的值的时候，主代码块中的 x 则不会受到影响。
随着最后一句 print 语句，我们展示出主代码块中定义的 x 的值，由此确认它实际上不受先前调用的函数中的局部变量的影响。

global

如果想给一个在程序顶层的变量赋值（也就是说它不存在于任何作用域中，无论是函数还是类），那么你必须告诉 Python 这一变量并非局部的，而是全局（Global）的。我们需要通过 global 语句来完成这件事。因为在不使用 global 语句的情况下，不可能为一个定义于函数之外的变量赋值。

x = 50

def func():
	global x
	print('x is', x)
	x = 2
	print('Changed global x to', x)
	
func()
print('Value of x is', x)
#输出
#x is 50
#Changed global x to 2
#Value of x is 2

global 语句用以声明 x 是一个全局变量——因此，当我们在函数中为 x 进行赋值时，这一改动将影响到我们在主代码块中使用的 x 的值。
可以在同一句 global 语句中指定不止一个的全局变量，例如 global x, y, z 。

默认参数值

对于一些函数来说，可以通过在函数定义时附加一个赋值运算符（ = ）来为参数指定默认参数值。
要注意到，默认参数值应该是常数。更确切地说，默认参数值应该是不可变的。

def say(message, times=1):
	print(message * times)
	
say('Hello')
say('World', 5)
#输出
#Hello
#WorldWorldWorldWorldWorld

名为 say 的函数用以按照给定的次数打印一串字符串。如果我们没有提供一个数值，则将按照默认设置，只打印一次字符串。我们通过为参数 times 指定默认参数值 1 来实现这一点。
在第一次使用 say 时，我们只提供字符串因而函数只会将这个字符串打印一次。在第二次使用 say 时，我们既提供了字符串，同时也提供了一个参数 5 ，声明我们希望说（Say）这个字符串五次。
只有那些位于参数列表末尾的参数才能被赋予默认参数值，意即在函数的参数列表中拥有默认参数值的参数不能位于没有默认参数值的参数之前。
这是因为值是按参数所处的位置依次分配的。举例来说， def func(a, b=5) 是有效的，但 def func(a=5, b) 是无效的。

关键字参数

如果你有一些具有许多参数的函数，而你又希望只对其中的一些进行指定，那么你可以通过命名它们来给这些参数赋值——这就是关键字参数（Keyword Arguments）——我们使用命名（关键字）而非位置（一直以来我们所使用的方式）来指定函数中的参数。
这样做有两大优点——其一，我们不再需要考虑参数的顺序，函数的使用将更加容易。其二，我们可以只对那些我们希望赋予的参数以赋值，只要其它的参数都具有默认参数值。

def func(a, b=5, c=10):
	print('a is', a, 'and b is', b, 'and c is', c)
	
func(3, 7)
func(25, c=24)
func(c=50, a=100)
#输出
#a is 3 and b is 7 and c is 10
#a is 25 and b is 5 and c is 24
#a is 100 and b is 5 and c is 50

名为 func 的函数有一个没有默认参数值的参数，后跟两个各自带有默认参数值的参数。
在第一次调用函数时， func(3, 7) ，参数 a 获得了值 3 ，参数 b 获得了值 7 ，而 c获得了默认参数值 10 。
在第二次调用函数时， func(25, c=24) ，由于其所处的位置，变量 a 首先获得了值 25。然后，由于命名——即关键字参数——指定，变量 c 获得了值 24 。变量 b 获得默认参数值5 。
在第三次调用函数时， func(c=50, a=100) ，我们全部使用关键字参数来指定值。在这里要注意到，尽管 a 在 c 之前定义，但我们还是我们在变量 a 之前指定了变量 c 。

可变参数

当希望定义的函数里面能够有任意数量的变量，也就是参数数量是可变的，可以通过使用星号来实现。

def total(a=5, *numbers, **phonebook):
	print('a', a)
	
	#遍历元组中的所有项目
	for single_item in numbers:
		print('single_item', single_item)
	#遍历字典中的所有项目
	for first_part, second_part in phonebook.items():
		print(first_part,second_part)
		
print(total(10,1,2,3,Jack=1123,John=2231,Inge=1560))
#输出
#a 10
#single_item 1
#single_item 2
#single_item 3
#Inge 1560
#John 2231
#Jack 1123
#None

当我们声明一个诸如 *param 的星号参数时，从此处开始直到结束的所有位置参数（Positional Arguments）都将被收集并汇集成一个称为“param”的元组（Tuple）。
类似地，当我们声明一个诸如 **param 的双星号参数时，从此处开始直至结束的所有关键字参数都将被收集并汇集成一个名为 param 的字典（Dictionary）。

return

return 语句用于从函数中返回一个值。

def maximum(x, y):
	if x > y:
		return x
	elif x == y:
		return 'The numbers are equal'
	else:
		return y
		
print(maximum(2, 3))
#输出
#3

maximum 函数将会返回参数中的最大值，在本例中是提供给函数的数值。它使用一套简单的if…else 语句来找到较大的那个值并将其返回。
要注意到如果 return 语句没有搭配任何一个值则代表着返回 None 。 None 在 Python 中一个特殊的类型，代表着虚无。举个例子，它用于指示一个变量没有值，如果有值则它的值便是 None（虚无）。
每一个函数都在其末尾隐含了一句 return None ，除非你写了你自己的 return 语句。

DocStrings

def print_max(x, y):
	'''Prints the maximum of two numbers.
	
	The two values must be integers.'''
	x = int(x)
	y = int(y)
	if x > y:
		print(x, 'is maximum')
	else:
		print(y, 'is maximum')
		
print_max(3, 5)
print(print_max.__doc__)
#输出
#5 is maximum
#Prints the maximum of two numbers.
#
#The two values must be integers.

函数的第一行逻辑行中的字符串是该函数的文档字符串（DocString）。该文档字符串所约定的是一串多行字符串，其中第一行以某一大写字母开始，以句号结束。第二行为空行，后跟的第三行开始是任何详细的解释说明。
我们可以通过使用函数的 doc （注意其中的双下划綫）属性（属于函数的名称）来获取函数 print_max 的文档字符串属性。