python计算运动会某个参赛选手的得分。数据保存在文件中_Python基础教程之第二章---变量和字符串(1) 搬运...

Python变量及其使用

无论使用什么语言编程，其最终目的都是对数据进行处理。程序在编程过程中，为了处理数据更加方便，通常会将其存储在变量中。
形象地看，变量就像一个个小容器，用于“盛装”程序中的数据。除了变量，还有常量，它也能用来“盛装”数据，它们的区别是，常量一旦保存某个数据之后，该数据就不能发生改变；但变量保存的数据则可以多次发生改变，只要程序对变量重新赋值即可。
Python 使用等号（＝）作为赋值运算符，例如 a = 20 就是一条赋值语句，这条语句用于将 20 装入变量 a 中，这个过程就被称为赋值，即将 20 赋值给变量 a。
注意，变量名其实就是标识符，因此在命名时，既要遵守 Python 标识符命名规范，还要避免和 Python 内置函数以及 Python 保留字重名。
如果你接触过 C、C++、Java 这些高级编程语言会发现，它们在使用变量存储数据时，必须指定该变量所能存储的数据类型，以 C 语言为例：int a = 20
这行 C 语言代码的意思是，声明一个整形变量 a 来存储整数 20，这就意味着，我们无法用 a 存储小数、字符以及字符串等其他类型数据，这类编程语言被称为强类型语言。
和强类型语言相对应的是弱类型语言，Python 就是典型代表之一。弱类型语言有以下 2 个特征：

变量无须声明即可直接赋值，对一个不存在的变量赋值就相当于定义了一个新变量。

变量的数据类型可以动态改变：同一个变量可以一会儿被赋值为整数值，一会儿被赋值为字符串。

对于没有编程基础的读者，可以先不编写真正的 Python 程序，而是先打开 Python 的交互式解释器，在这个交互式解释器中“试验” Python。首先，在 Python 解释器中输入如下内容：>>> a = 5
>>>
上面代码没有生成任何输出，只是向交互式解释器中存入了一个变量 a，该变量 a 的值为 5。
如果我们想看到某个变量的值，可以直接在交互式解释器中输入该变量。例如，此处想看到变量 a 的值，可以直接输入 a。>>> a
5
>>>
可以看到，Python 解释器输出变量 a 的值为 5。
接下来，我们尝试改变变量 a 的值，将新的值赋给变量 a，例如：>>>a = 'Hello , Charlie'
>>>
这会导致变量原来的值被新值覆盖掉，换句话说，此时变量 a 的值就不再是 5 了，而是字符串“Hello , Charlie”，a 的类型也变成了字符串。现在再输入 a，让交互式解释器显示 a 的值：>>> a
'Hello , Charlie'
如果想查看此时 a 的类型，可以使用 Python 的 type() 内置函数。>>> type(a)
<class 'str'>
>>>
可以看到，a 的类型是 str（表示字符串类型）。
形象地说，函数就相当于一个有魔法的“黑盒子”，你可以向这个“黑盒子“提供”一些数据，这个“黑盒子”会对这些数据进行处理，这种处理包括转换和输出结果。比如 print() 也是一个函数，它的作用就是输出传入的数据。此处 type() 函数的作用则用于输出传入数据的类型。
最后，如果想把上面的交互过程转换成真正的 Python 程序，只要将过程中输入的每行代码放在一个文件中，并使用 print() 函数来输出变量，最后将该文件保存为以 .py 结尾的源文件即可。
在交互式解释器中，只要输入变量名，交互式解释器就会输出变量的值，但在 Python 程序中则必须使用 print() 函数来输出变量。
上面的交互过程对应的程序如下：

#定义一个数值类型变量

a = 5

print(a)

#重新将字符串赋值给a变量

a = 'Hello , Charlie'

print(a)

print(type(a))

Python变量命名规则（超级详细）

Python 需要使用标识符给变量命名，其实标识符就是用于给程序中变量、类、方法命名的符号（简单来说，标识符就是合法的名字）。
Python 语言的标识符必须以字母、下画线（_）开头，后面可以跟任意数目的字母、数字和下画线（_）。此处的字母并不局限于 26 个英文字母，可以包含中文字符、日文字符等。
由于 Python 3 支持 UTF-8 字符集，因此 Python 3 的标识符可以使用 UTF-8 所能表示的多种语言的字符。Python 语言是区分大小写的，因此 abc 和 Abc 是两个不同的标识符。
Python 2.x 对中文支持较差，如果要在 Python 2.x 程序中使用中文字符或中文变量，则需要在 Python 源程序的第一行增加“#coding:utf-8”，当然别忘了将源文件保存为 UTF-8 字符集。
在使用标识符时，需要注意如下规则：

标识符可以由字母、数字、下画线（_）组成，其中数字不能打头。

标识符不能是 Python 关键字，但可以包含关键字。

标识符不能包含空格。

例如下面变量，有些是合法的，有些是不合法的：

• abc_xyz：合法。
• HelloWorld：合法。
• abc：合法。
• xyz#abc：不合法，标识符中不允许出现“#”号。
• abc1：合法。
• 1abc：不合法，标识符不允许数字开头。

Python 的关键字和内置函数
Python 还包含一系列关键字和内置函数，一般也不建议使用它们作为变量名：

• 如果开发者尝试使用关键字作为变量名，Python 解释器会报错。
• 如果开发者使用内置函数的名字作为变量名，Python 解释器倒不会报错，只是该内置函数就被这个变量覆盖了，该内置函数就不能使用了。

Python 包含了如表 1 所示的关键字：
表 1 Python 关键字FalseNoneTrueandasassert breakclasscontinuedefdelelifelse exceptfinallyforfromglobalifimportinislambdanonlocalnotorpassraisereturntrywhilewithyield
实际上 Python 非常方便，开发者可以通过 Python 程序来查看它所包含的关键字。例如，对于如下程序：

#导入keyword 模块

import keyword

#显示所有关键字

keyword.kwlist

从上面代码可以看出，程序只要先导入 keyword 模块，然后调用 keyword.kwlist 即可查看 Python 包含的所有关键字。运行上面程序，可以看到如下输出结果：
['False','None','True','and','as','assert','break','class','continue','def','del','elif','else','except','finally','for','from','global','if','import','in','is','lambda','nonlocal','not','or','pass','raise','return','try','while','With','yield']
上面这些关键字都不能作为变量名。
此外，Python 3 还提供了如表 2 所示的内置函数。
表 2 Python内置函数abs()all()any()basestring()bin()bool()bytearray()callable()chr()classmethod()cmp()compile() complex()delattr()dict()dir()divmod()enumerate() eval()execfile()file()filter()float() format()frozenset()getattr()globals()hasattr()hash()help()hex()id()input()int() isinstance()issubclass()iter()len()list()locals()long()map() max()memoryview()min()next() object()oct() open() ord()pow()print()property()range()raw_input()reduce()reload()repr()reversed()zip()round() set()setattr()slice()sorted()staticmethod()str()sum()super()tuple()type()unichr()unicode() vars()xrange()Zip()__import__()apply()buffer()coerce()intern
上面这些内置函数的名字也不应该作为标识符，否则 Python 的内置函数会被覆盖。

注意：在 Python 2.x 中，print 是关键字而不是函数。上面这些内置函数（如 unicode()）只是 Python 2.x 的内置函数，为了保证 Python 程序具有更好的兼容性，程序也不应该使用这些内置函数的名字作为标识符。

Python数值类型（整形、浮点型和复数）及其用法

实际开发中，我们经常需要使用数字记录游戏中用户的得分、游戏中角色的生命值、伤害值等信息，Python 语言提供了数值类型用于保存这些数值。
需要注意的是，Python 中这些数值类型都是不可改变的，也就是说，如果我们要修改数字类型变量的值，那么其底层实现的过程是，先将新值存放到内存中，然后修改变量让其指向新的内存地址，换句话说，Python 中修改数值类型变量的值，其实只是修改变量名所表示的内存空间。
数值类型只是一个泛泛的统称，Python 中的数值类型主要包括整形、浮点型和复数类型。
Python整型
整形专门用来表示整数，即没有小数部分的数。在 Python 中，整数包括正整数、0 和负整数。
和其他强类型语言不同，它们会提供多种整形类型，开发者要根据数值的大小，分别用不同的整形类型存储，以 C 语言为例，根据数值的大小，开发者要合理选择 short、int、long 整形类型存储，大大增加了开发难度。
Python 则不同，它的整型支持存储各种整数值，无论多大或者多小，Python 都能轻松处理（当所用数值超过计算机自身的计算功能时，Python 会自动转用高精度计算）。
例如如下代码：

#定义变量a，赋值为56

a = 56

print(a)

#为a赋值一个大整数

a = 9999999999999999999999

print(a)

#type()函数用于返回变量的类型

print(type (a))

对于没有编程基础的读者， 同样可以在交互式解释器中逐行“试验”上面程序来观看运行效果。由于篇幅限制，本教程后面的程序不再详细列出在交互式解释器中逐行“试验”的过程。
上面程序中，将 9999999999999999999999 大整数赋值给变量 a，Python 也不会发生溢出等问题，程序运行一样正常，这足以证明 Python 的强大。
使用 Python 3.x 运行上面程序，可以看到如下输出结果：56
9999999999999999999999
<class 'int'>
从上面的输出结果可以看出，此时 a 依然是 int 类型。
但如果用 Python 2.x 运行上面程序，由于输入的数值比较大，Python 会自动在其后面加上字母 L（或小写字母 l），如下输出结果：
56
9999999999999999999999L
<type 'long'>
对比两种输出结果，不难发现：不管是 Python 3.x 还是 Python 2.x，Python 完全可以正常处理很大的整数，只是 Python 2.x 底层会将大整数当成 long 类型处理，但开发者通常不需要理会这种细节。
除此之外，Python 的整型还支持 None 值（空值），例如如下代码：a = None
print(a) #什么都不输出
Python 的整型数值有 4 种表示形式：

十进制形式：最普通的整数就是十进制形式的整数，在使用十进制表示整数值时，不能以 0（零）作为十进制数的开头（数值是 0 除外）。

二进制形式：由 0 和 1 组成，以 0b 或 0B 开头。例如，101 对应十进制数是 5；

八进制形式：八进制整数由 0~7 组成，以 0o 或 0O 开头（第一个字母是零，第二个字母是大写或小写的 O）。需要注意的是，在 Python 2.x 中，八进制数值还可以直接以 0（零）开头。

十六进制形式：由 0~9 以及 A~F（或 a~f）组成，以 0x 或 0X 开头，

下面代码片段使用了其他进制形式的数：

#以0x或0X开头的整型数值是十六进制形式的整数

hex_value1 = 0x13

hex_value2 = 0xaF

print("hexValue1 的值为：",hex_value1)

print("hexValue2 的值为：",hex_value2)

#以0b或0B开头的整型数值是二进制形式的整数

bin_val = 0b111

print('bin_val的值为：',bin_val)

bin_val = 0B101

print('bin_val的值为：',bin_val)

#以0o或0O开头的整型数值是八进制形式的整数

oct_val = 0o54

print('oct_val 的值为：',oct_val)

oct_val = 0O17

print('oct_val 的值为：',oct_val)

为了提高数值（包括浮点型）的可读性，Python 3.x 允许为数值（包括浮点型）增加下画线作为分隔符。这些下画线并不会影响数值本身。例如如下代码：

#在数值中使用下画线

one_million = 1000000

print(one_million)

price = 234_234_234 #price 实际的值为234234234

android = 1234_1234 #android 实际的值为12341234

Python浮点型
浮点型数值用于保存带小数点的数值，Python 的浮点数有两种表示形式：

• 十进制形式：这种形式就是平常简单的浮点数，例如 5.12、512.0、0.512。浮点数必须包含一个小数点，否则会被当成整数类型处理。
• 科学计数形式：例如 5.12e2（即 5.12×102）、5.12E2（也是 5.12 ×102）。

必须指出的是，只有浮点型数值才可以使用科学计数形式表示。例如 51200 是一个整型值，但 512E2 则是浮点型值。
下面程序示范了上面介绍的关于浮点数的各个知识点：

af1 = 5.2345556

#输出af1的值

print("af1的值为：",af1)

af2 = 25.2345

print("af2的类型为：",type(af2))

f1=5.12e2

print("f1的值为：",f1)

f2 = 5e3

print("f2的值为：",f2)

print("f2的类型为：",type(f2))#看到类型为float

通过第 8 行代码可以看出，虽然 5e3 的值是 5000，但它依然是浮点型值，而不是整型值，因为 Python 会自动将该数值变为 5000.0。
注意，使用浮点数进行计算时，可能会出现小数位数不确定的情况，比如说，计算 0.1+0.2，本来应该得到 0.3，但经过测试你会发现，Python解释器的运行结果为 0.30000000000000004。几乎所有编程语言都存在这个问题，这与浮点数在底层的存储方式有关系（后续章节会做详细介绍）。
Python复数
Python 甚至可以支持复数，复数的虚部用 j 或 J 来表示。
如果读者对虚数虚部感到困惑，请直接跳过本节，大部分编程并不会用到复数这么“高级”的数学知识。
如果需要在程序中对复数进行计算，可导入 Python 的 cmath 模块（c 代表 complex），在该模块下包含了各种支持复数运算的函数。
模块就是一个 Python 程序，Python 正是通过模块提高了自身的可扩展性的；Python 本身内置了大量模块，此外还有大量第三方模块，导入这些模块即可直接使用这些程序中定义的函数。
下面程序示范了复数的用法：
纯文本复制

ac1 = 3 + 0.2j

print (ac1)

print(type(ac1)) #输出复数类型

ac2 = 4 - 0.1j

print(ac2)

#复数运行

print(ac1 + ac2) #输出(7+0.1j)

#导入cmath 模块

import cmath

#sqrt()是cmath 模块下的商数，用于计算平方根

ac3 = cmath.sqrt(-1)

print (ac3) #输出1j

Python字符串及基本操作（入门必看）

字符串的意思就是“一串字符”，比如“Hello,Charlie”是一个字符串，“How are you？”也是一个字符串。
Python 要求字符串必须使用引号括起来，使用单引号也行，使用双引号也行，只要两边的引号能配对即可。
Python字符串和转义字符
字符串的内容几乎可以包含任何字符，英文字符也行，中文字符也行。
Python 3.x 对中文字符支持较好，但 Python 2.x 则要求在源程序中增加“#coding:utf-8”才能支持中文字符。
字符串既可用单引号括起来，也可用双引号括起来，它们没有任何区别。例如如下程序：

str1 = 'Charlie'

str2 = "C语言中文网"

print(str1)

print(str2)

但需要说明的是，Python 有时候没有我们期望的那么聪明。如果字符串内容本身包含了单引号或双引号，此时就需要进行特殊处理：

使用不同的引号将字符串括起来。

对引号进行转义。

先看第一种处理方式。假如字符串内容中包含了单引号，则可以使用双引号将字符串括起来。例如：str3 = 'I'm a coder'
由于上面字符串中包含了单引号，此时 Python 会将字符串中的单引号与第一个单引号配对，这样就会把 'I' 当成字符串，而后面的 m a coder' 就变成了多余的内容，从而导致语法错误。
为了避免这种问题，可以将上面代码改为如下形式：
str3 = "I'm a coder"
上面代码使用双引号将字符串括起来，此时 Python 就会把字符串中的单引号当成字符串内容，而不是和字符串开始的引号配对。
假如字符串内容本身包含双引号，则可使用单引号将字有串括起来，例如如下代码：
str4 = '"Spring is here,let us jam!", said woodchuck.'
接下来看第二种处理方式：使用转义字符。Python 允许使用反斜线（）将字符串中的特殊字符进行转义。假如字符串既包含单引号，又包含双引号，此时必须使用转义字符，例如如下代码：
str5 = '"we are scared,Let's hide in the shade",says the bird'
拼接字符串
如果直接将两个字符串紧挨着写在一起，Python 就会自动拼接它们，例如如下代码：

s1 = "Hello,"'Charlie'

print(s1)

上面代码将会输出：Hello,Charlie
上面这种写法只是书写字符串的一种特殊方法，并不能真正用于拼接字符串。Python 使用加号（+）作为字符串的拼接运算符，例如如下代码：

s2 = "Python "

s3 = "iS Funny"

#使用+拼接字符串

s4 = s2 + s3

print(s4)

repr 和字符串
有时候，我们需要将字符串与数值进行拼接，而 Python 不允许直接拼接数值和字符串，程序必须先将数值转换成字符串。
为了将数值转换成字符串，可以使用 str() 或 repr() 函数，例如如下代码：

s1 = "这是数字: "

p = 99.8

#字符串直接拼接数值，程序报错

print(s1 + p)

#使用str()将数值转换成字符串

print(s1 + str(p))

#使用repr()将数值转换成字符串

print(s1 + repr(p))

上面程序中直接拼接字符串和数值，程序会报错。
str() 和 repr() 函数都可以将数值转换成字符串，其中 str 本身是 Python 内置的类型（和 int、float 一样），而 repr() 则只是一个函数。此外，repr 还有一个功能，它会以 Python 表达式的形式来表示值。对比如下代码：

st = "I will play my fife"

print (st)

print(repr(st))

上面代码中 st 本身就是一个字符串，但程序依然使用了 repr() 对字符串进行转换。运行上面程序，可以看到如下输出结果：
I will play my fife
'I will play my fife'
通过上面的输出结果可以看出，如果直接使用 print() 函数输出字符串，将只能看到字符串的内容，没有引号；但如果先使用 repr() 函数对字符串进行处理，然后再使用 print() 执行输出，将可以看到带引号的字符串，这就是字符串的 Python 的表达式形式。
在交互式解释器中输入一个主量或表达式时，Python 会自动使用 repr() 函数处理该变量或表达式。
使用 input 和 raw_input 获取用户输入
input() 函数用于向用户生成一条提示，然后获取用户输入的内容。由于 input() 函数总会将用户输入的内容放入字符串中，因此用户可以输入任何内容，input() 函数总是返回一个字符串。
例如如下程序：

msg ＝ input("请输入你的值：")

print (type(msg))

print(msg)

第一次运行该程序，我们输入一个整数，运行过程如下：
请输入你的值：2
<class 'str'>
2
第二次运行该程序，我们输入一个浮点数，运行过程如下：
请输入你的值： 1.2
<class 'str'>
1.2
第三次运行该程序，我们输入一个字符串，运行过程如下：请输入你的值：Hello
<class 'str'>
Hello
从上面的运行过程可以看出，无论输入哪种内容，始终可以看到 input() 函数返回字符串，程序总会将用户输入的内容转换成字符串。
需要指出的是，Python 2.x 提供了一个 raw_input() 函数，该 raw_input() 函数就相当于 Python 3.x 中的 input() 函数。
而 Python 2.x 也提供了一个 input() 函数，该 input() 函数则比较怪异：要求用户输入的必须是符合 Python 语法的表达式。通常来说，用户只能输入整数、浮点数、复数、字符串等。重点是格式必须正确，比如输入字符串时必须使用双引号，否则 Python 就会报错。
使用 Python 2.x 来运行上面程序，假如输入一个整数，运行过程如下：
请输入你的值：2
<class 'int'>
2
使用 Python 2.x 来运行上面程序，假如输入一个复数，运行过程如下：请输入你的值： 2+3j
<type 'complex'>
(2+3j)
使用 Python 2.x 来运行上面程序，假如输入一个字符串，运行过程如下：
请输入你的值：Hello
NameError : name 'Hello' is not defined
上面程序报错的原因是：Python 2.x 的 input() 函数要求用户输入字符串时必须用引号把字符串括起来。
在 Python 2.x 中应该尽量使用 raw_input() 函数来获取用户输入；Python 2.x 中的 raw_input() 等同于 Python 3.x 中的 input()。
Python长字符串
前面介绍 Python 多行注释时提到使用三个引号（单引号、双引号都行）来包含多行注释内容，其实这是长字符串写法，只是由于在长字符串中可以放置任何内容，包括放置单引号、双引号都可以，如果所定义的长字符串没有赋值给任何变量，那么这个字符串就相当于被解释器忽略了，也就相当于注释掉了。
实际上，使用三个引号括起来的长字符串完全可以赋值给变量，例如如下程序：

s = '''"Let's go fishing", said Mary.

"OK, Let's go", said her brother.

they walked to a lake'''

print(s)

上面程序使用三个引号定义了长字符串，该长字符串中既可包含单引号，也可包含双引号。
当程序中有大段文本内容要定义成字符串时，优先推荐使用长字符串形式，因为这种形式非常强大，可以让字符串中包含任何内容，既可包含单引号，也可包含双引号。
此外，Python 还允许使用转义字符（）对换行符进行转义，转义之后的换行符不会“中断”字符串。例如如下代码：

s2 = 'The quick brown fox

jumps over the lazy dog'

print(s2)

上面 s2 字符串的内容较长，故程序使用了转义字符（）对内容进行了转义，这样就可以把一个字符串写成两行。
需要说明的是，Python 不是格式自由的语言，因此 Python 程序的换行、缩进都有其规定的语法。所以，Python 的表达式不允许随便换行。如果程序需要对 Python 表达式换行，同样需要使用转义字符（）进行转义，代码如下：

num = 20 + 3 / 4 +

2 * 3

print(num)

上面程序中有一个表达式，为了对该表达式换行，程序需要使用转义字符。
Python原始字符串
由于字符串中的反斜线都有特殊的作用，因此当字符串中包含反斜线时，就需要对其进行转义。
比如写一条 Windows 的路径 G:publishcodes022.4，如果在 Python 程序中直接这样写肯定是不行的，需要写成 G:publishcodes022.4，这很烦人，此时可借助于原始字符串来解决这个问题。
原始字符串以“r”开头，原始字符串不会把反斜线当成特殊字符。因此，上面的 Windows 路径可直接写成 r'G:publishcodes022.4'。
关于原始字符串的用法看如下程序：

s1 = r'G:publishcodes022.4'

print(s1)

如果原始字符串中包含引号，程序同样需要对引号进行转义（否则 Python 同样无法对字符串的引号精确配对），但此时用于转义的反斜线会变成字符串的一部分。
例如如下代码：

# 原始字符串包含的引号，同样需要转义

s2 = r'"Let's go", said Charlie'

print(s2)

上面代码会生成如下输出结果："Let's go", said Charlie
由于原始字符串中的反斜线会对引号进行转义，因此原始字符串的结尾处不能是反斜线，否则字符串结尾处的引号就被转义了，这样就导致字符串不能正确结束。
如果确实要在原始字符串的结尾处包含反斜线怎么办呢？一种方式是不要使用原始字符串，而是改为使用长字符串写法（三引号字符串）；另一种方式就是将反斜线单独写。
例如如下代码：
纯文本复制

s3 = r'Good Morning' ''

print(s3)

有什么学的蒙的可以交流

总结

以上是生活随笔为你收集整理的python计算运动会某个参赛选手的得分。数据保存在文件中_Python基础教程之第二章---变量和字符串(1) 搬运...的全部内容，希望文章能够帮你解决所遇到的问题。

如果觉得生活随笔网站内容还不错，欢迎将生活随笔推荐给好友。