每种编程语言都有自己的语法规则，就像我们说的语言一样。

关键字和标识符

以下标识符用作保留字或语言的关键字，不能用作普通标识符。 它们必须完全按照此处所写的方式输入：

  1. False      class      finally    is         return
  2. None       continue   for        lambda     try
  3. True       def        from       nonlocal   while
  4. and        del        global     not        with
  5. as         elif       if         or         yield
  6. assert     else       import     pass
  7. break      except     in         raise

在 Python 中，我们没有指定将要放入变量的数据类型。 所以你可以直接写 abc = 1， abc 会变成整数类型。 如果你写 abc = 1.0，abc 就会变成浮点类型。 这里有一个将两个给定数字相加的小程序

  1. >>> a = 13
  2. >>> b = 23
  3. >>> a + b
  4. 36

从上面的示例中可以理解，要在 Python 中声明变量，只需要输入名称和值。Python 还可以操作字符串，它们可以用单引号或双引号括起来

  1. >>> 'India'
  2. 'India'
  3. >>> 'India\'s best'
  4. "India's best"
  5. >>> "Hello World!"
  6. 'Hello World!'

从键盘读取输入

通常，现实生活中的 Python 代码不需要从键盘读取输入。 在 Python 中，我们使用 input 函数来进行输入。 input(“String to show”) ，这将返回一个字符串作为输出。 让我们编写一个程序来从键盘读取一个数字并检查它是否小于 100。 程序名称是 testhundred.py

  1. #!/usr/bin/env python3
  2. number = int(input("Enter an integer: "))
  3. if number < 100:
  4.     print("Your number is smaller than 100")
  5. else:
  6.     print("Your number is greater than 100")

输出

  1. $ ./testhundred.py
  2. Enter an integer: 13
  3. Your number is smaller than 100
  4. $ ./testhundred.py
  5. Enter an integer: 123
  6. Your number is greater than 100

在下一个程序中，我们将计算投资。

  1. #!/usr/bin/env python3
  2. amount = float(input("Enter amount: "))
  3. inrate = float(input("Enter Interest rate: "))
  4. period = int(input("Enter period: "))
  5. value = 0
  6. year = 1
  7. while year <= period:
  8.     value = amount + (inrate * amount)
  9.     print("Year %d Rs. %.2f" % (year, value))
  10.     amount = value
  11.     year = year + 1

输出

  1. $ ./investment.py
  2. Enter amount: 10000
  3. Enter Interest rate: 0.14
  4. Enter period: 5
  5. Year 1 Rs. 11400.00
  6. Year 2 Rs. 12996.00
  7. Year 3 Rs. 14815.44
  8. Year 4 Rs. 16889.60
  9. Year 5 Rs. 19254.15

一些例子

一些变量和数据类型的例子：

N 个数字的平均值

在下面程序中，我们将计算 N 个数字的平均值。

  1. #!/usr/bin/env python3
  2. N = 10
  3. sum = 0
  4. count = 0
  5. while count < N:
  6.     number = float(input(""))
  7.     sum = sum + number
  8.     count = count + 1
  9. average = float(sum)/N
  10. print("N = %d , Sum = %f" % (N, sum))
  11. print("Average = %f" % average)

输出

  1. $ ./averagen.py
  2. 1
  3. 2.3
  4. 4.67
  5. 1.42
  6. 7
  7. 3.67
  8. 4.08
  9. 2.2
  10. 4.25
  11. 8.21
  12. N = 10 , Sum = 38.800000
  13. Average = 3.880000

温度转换

在这个程序中，我们将使用公式 C=(F-32)/1.8 将给定的温度从华氏温度转换为摄氏温度

  1. #!/usr/bin/env python3
  2. fahrenheit = 0.0
  3. print("Fahrenheit Celsius")
  4. while fahrenheit <= 250:
  5.     celsius = ( fahrenheit - 32.0 ) / 1.8 # Here we calculate the Celsius value
  6.     print("%5.1f %7.2f" % (fahrenheit , celsius))
  7.     fahrenheit = fahrenheit + 25

输出

  1. $ ./temperature.py
  2. Fahrenheit Celsius
  3. 0.0  -17.78
  4. 25.0   -3.89
  5. 50.0   10.00
  6. 75.0   23.89
  7. 100.0   37.78
  8. 125.0   51.67
  9. 150.0   65.56
  10. 175.0   79.44
  11. 200.0   93.33
  12. 225.0  107.22
  13. 250.0  121.11

单行中的多个变量赋值

甚至可以在一行中为多个变量赋值，如

  1. >>> a , b = 45, 54
  2. >>> a
  3. 45
  4. >>> b
  5. 54

使用这个交换两个数字变得非常容易

  1. >>> a, b = b , a
  2. >>> a
  3. 54
  4. >>> b
  5. 45

为了理解其工作原理，你必须了解一种名为 tuple 的数据类型。我们用逗号来创建元组。 在右侧，我们创建了元组（我们称之为元组打包），在左侧，我们将元组拆包为一个新的元组。

下面我们有另一个元组拆包的例子。

  1. >>> data = ("Kushal Das", "India", "Python")
  2. >>> name, country, language = data
  3. >>> name
  4. 'Kushal Das'
  5. >>> country
  6. 'India'
  7. >>> language
  8. 'Python'

不能修改元组。如果您希望有任何更改，则必须创建另一个新元组。很多时候，我们创建用 CAPS 编写的变量来标记程序运行时不会改变的值(常量)。例如，如果我们认为颜色是 RGB 值的元组，那么我们可以将它们定义为:

元组不能被修改。 如果你想进行任何更改，则必须创建另一个新元组。 很多时候，我们创建用全大写字母编写的变量来标记在程序运行时不会改变的值（常量）。 例如，如果我们将颜色视为 RGB 值的元组，那么我们可以将它们定义为：

  1. >>> RED = (255, 0, 0)
  2. >>> GREEN = (0, 255, 0)
  3. >>> BLUE = (0, 0, 255)
  4. >>> print(RED)
  5. (255, 0, 0)

格式化字符串

在 Python 3 中，有几种不同的方式来格式化字符串。 我们使用这些方法来动态格式化文本。 我将在下面的举几个例子。

在 Python 3.6 中，我们有一种新的字符串格式化方法。 PEP 498 引入了称为 f-strings 的概念。

以下是使用 f-strings 的相同示例：

  1. >>> name = "Kushal"
  2. >>> language = "Python"
  3. >>> msg = f"{name} loves {language}."
  4. >>> print(msg)
  5. Kushal loves Python.

f-strings 提供了一种简单易读的方法，可以将 Python 表达式嵌入到字符串中。这里还有几个例子。

  1. >>> answer = 42
  2. >>> print(f"The answer is {answer}")
  3. The answer is 42
  4. >>> import datetime
  5. >>> d = datetime.date(2004, 9, 8)
  6. >>> f"{d} was a {d:%A}, we started the mailing list back then."
  7. '2004-09-08 was a Wednesday, we started the mailing list back then.'

如果您想了解有关这个特性如何进入 Python 的更多信息，请观看 Mariatta Wijaya 的演讲。

在 Python3.8 中，我们可以使用以下样式来帮助打印值和变量名。

  1. >>> a = 1
  2. >>> b = 2
  3. >>> print(f"{a=} and {b=}")
  4. a=1 and b=2

.format 方法

我们也可以在字符串中使用 format 方法

  1. >>> name = "Kushal"
  2. >>> language = "Python"
  3. >>> msg = "{0} loves {1}.".format(name, language)
  4. >>> print(msg)
  5. Kushal loves Python.