Python 极速入门指南

2021年5月4日 2点热度 0条评论 来源: *Clouder

前言

转载于本人博客

面向有编程经验者的极速入门指南。

大部分内容简化于 W3School,翻译不一定准确,因此标注了英文。

包括代码一共两万字符左右,预计阅读时间一小时。

目前我的博客长文显示效果不佳,缺乏目录,因此可以考虑下载阅读。博客完全开源于 Github.

目录

语法(Syntax)

文件执行方式:python myfile.py

强制缩进,缩进不能省略。缩进可以使用任意数量的空格。

if 5 > 2:
 print("Five is greater than two!") 
if 5 > 2:
        print("Five is greater than two!") 

注释(Comment)

注释语法:

# Single Line Comment
"""
Multiple
Line
Comment
"""

变量(Variables)

当变量被赋值时,其被创建。
没有显式声明变量的语法。

x = 5
y = "Hello, World!"

可以转换类型。

x = str(3)    # x will be '3'
y = int(3)    # y will be 3
z = float(3)  # z will be 3.0

可以获得类型。

x = 5
y = "John"
print(type(x))
print(type(y))

还可以这样赋值:

x, y, z = "Orange", "Banana", "Cherry"
x = y = z = "Orange"
fruits = ["apple", "banana", "cherry"]
x, y, z = fruits

没有在函数中声明的变量一律视作全局变量。

x = "awesome"
def myfunc():
  print("Python is " + x)
myfunc()

局部变量优先。

x = "awesome"
def myfunc():
  x = "fantastic"
  print("Python is " + x)
myfunc()
print("Python is " + x)

也可以显式声明全局变量。

def myfunc():
  global x
  x = "fantastic"
myfunc()
print("Python is " + x)

由于不能区分赋值和声明,因此如果在函数中修改全局变量,需要指明全局。

x = "awesome"
def myfunc():
  global x
  x = "fantastic"
myfunc()
print("Python is " + x)

数值(Number)

三种数值类型:int float complex

其中复数的虚部用 j 来表示。

x = 3+5j
y = 5j
z = -5j

print(type(x))
print(type(y))
print(type(z))

真值(Boolean)

使用 TrueFalse,大小写敏感。

可以强制转换:

x = "Hello"
y = 15

print(bool(x))
print(bool(y))

空值一般转换为假,例如零、空文本、空集合等。

条件与循环(If...Else/While/For)

大于小于等于不等于跟 C 语言一致。

如果:

a = 200
b = 33
if b > a:
  print("b is greater than a")
elif a == b:
  print("a and b are equal")
else:
  print("a is greater than b")

适当压行也是可以的:

if a > b: print("a is greater than b")

三目运算符,需要注意的是执行语句在前面。

a = 2
b = 330
print("A") if a > b else print("B")
print("A") if a > b else print("=") if a == b else print("B")

与或:

a = 200
b = 33
c = 500
if a > b and c > a:
  print("Both conditions are True")
if a > b or a > c:
  print("At least one of the conditions is True")

如果不能为空,可以传递个 pass 占位。

if b > a:
  pass

while 循环很常规:

i = 1
while i < 6:
  print(i)
  if i == 3:
    break
  if i == 4:
    continue
  i += 1

还有个 else 的语法:

i = 1
while i < 6:
  print(i)
  i += 1
else:
  print("i is no longer less than 6")

这个有什么用呢?其实是可以判断自然结束还是被打断。

i = 1
while i < 6:
  break
else:
  print("i is no longer less than 6")

Python 中的 for 循环,更像是其他语言中的 foreach.

fruits = ["apple", "banana", "cherry"]
for x in fruits:
  if x == "apple":
    continue
  print(x)
  if x == "banana":
    break

为了循环,可以用 range 生成一个数组。依然是左闭右开。可以缺省左边界 0.

for x in range(6): #generate an array containing 0,1,2,3,4,5
  print(x)
for x in range(2, 6): #[2,6)
  print(x)

可以指定步长,默认为 1.

for x in range(2, 30, 3):
  print(x)

也支持 else

for x in range(6):
  print(x)
else:
  print("Finally finished!")

也可以拿 pass 占位。

for x in [0, 1, 2]:
  pass

字符串(String)

有两种写法:

print("Hello")
print('Hello')

好像没什么区别。

多行字符串:

a = """Lorem ipsum dolor sit amet,
consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua."""
print(a)

字符串可以直接当数组用。

a = "Hello, World!"
print(a[0])

获得长度。

a = "Hello, World!"
print(len(a))

直接搜索。

txt = "The best things in life are free!"
print("free" in txt)
print("expensive" not in txt)
if "free" in txt:
  print("Yes, 'free' is present.")
if "expensive" not in txt:
  print("Yes, 'expensive' is NOT present.")

几个常用函数:

  • upper,大写。
  • lower,小写。
  • strip,去除两端空格。
  • replace,替换。
  • split,以特定分隔符分割。

连接两个字符串,直接用加号。

a = "Hello"
b = "World"
c = a + b
print(c)

格式化:

quantity = 3
itemno = 567
price = 49.95
myorder = "I want {} pieces of item {} for {} dollars."
print(myorder.format(quantity, itemno, price))

可以指定参数填入的顺序:

myorder = "I want to pay {2} dollars for {0} pieces of item {1}."
print(myorder.format(quantity, itemno, price))

转义符:\

txt = "We are the so-called \"Vikings\" from the north."

操作符(Operators)

  • 算术运算符

    • +
    • -
    • *
    • /
    • %,取模。
    • **,次幂,例如 2**10 返回 \(1024\).
    • //,向下取整,严格向下取整,例如 -11//10 将会得到 \(-2\).
  • 比较运算符

    • ==
    • !=
    • >
    • <
    • >=
    • <=
  • 逻辑运算符,使用英文单词而非符号。

    • and
    • or
    • not
  • 身份运算符?(Identity Operators)

    • is
    • is not
    • 用于判断是否为同一个对象,即在内存中处于相同的位置。
  • 成员运算符?(Membership Operators)

    • in
    • not in
    • 用在集合中。
  • 位运算符

    • &
    • |
    • ^
    • ~
    • <<
    • >>

集合(Collections)

数组(List)

没有 Array,只有 List.

thislist = ["apple", "banana", "cherry"]
print(thislist)

下标从零开始。

thislist = ["apple", "banana", "cherry"]
print(thislist[0])

还可以是负的,-1 表示倒数第一个,依此类推。

thislist = ["apple", "banana", "cherry"]
print(thislist[-1])

获取子数组,左闭右开。例如 [2:5] 代表 [2,5)

thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[2:5])

还可以去头去尾。

thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[:4])
print(thislist[2:])

获得元素个数:

thislist = ["apple", "banana", "cherry"]
print(len(thislist))

元素类型都可以不同:

list1 = ["abc", 34, True, 40, "male"]

构造:

thislist = list(("apple", "banana", "cherry")) # note the double round-brackets
print(thislist)

赋值:

thislist = ["apple", "banana", "cherry"]
thislist[1] = "blackcurrant"
print(thislist)

甚至一次改变一个子数组:

thislist = ["apple", "banana", "cherry", "orange", "kiwi", "mango"]
thislist[1:3] = ["blackcurrant", "watermelon"]
print(thislist)

元素数量可以不对等,可以视作将原数组中的 [l,r) 扔掉,然后从切口塞进去新的子数组。

thislist = ["apple", "banana", "cherry"]
thislist[1:2] = ["blackcurrant", "watermelon"]
print(thislist)

支持插入,应该是 \(O(n)\) 复杂度的。insert(x,"something") 即让 something 成为下标为 x 的元素,也就是插入到当前下标为 x 的元素前。

thislist = ["apple", "banana", "cherry"]
thislist.insert(2, "watermelon")
print(thislist)

尾部追加,应该是 \(O(1)\) 的。

thislist = ["apple", "banana", "cherry"]
thislist.append("orange")
print(thislist)

直接连接两个数组:

thislist = ["apple", "banana", "cherry"]
tropical = ["mango", "pineapple", "papaya"]
thislist.extend(tropical)
print(thislist)

啥都能连接?

thislist = ["apple", "banana", "cherry"]
thistuple = ("kiwi", "orange")
thislist.extend(thistuple)
print(thislist)

删除,一次只删一个。

thislist = ["apple", "banana", "cherry"]
thislist.remove("banana")
print(thislist)

按下标删除。可以省略参数,默认删除最后一个。

thislist = ["apple", "banana", "cherry"]
thislist.pop(1)
thislist.pop()
print(thislist)

还可以用 del 关键字。

thislist = ["apple", "banana", "cherry"]
del thislist[0]
print(thislist)
del thislist #delete the entire list

清空,数组对象依然保留。

thislist = ["apple", "banana", "cherry"]
thislist.clear()
print(thislist)

可以直接用 for 来遍历。

thislist = ["apple", "banana", "cherry"]
for x in thislist:
  print(x)

也可以用下标遍历。

thislist = ["apple", "banana", "cherry"]
for i in range(len(thislist)):
  print(thislist[i])

为了性能,也可以用 while 来遍历,避免 range 生成过大的数组。

thislist = ["apple", "banana", "cherry"]
i = 0
while i < len(thislist):
  print(thislist[i])
  i = i + 1

缩写的 for 遍历,两边中括号是必须的。

thislist = ["apple", "banana", "cherry"]
[print(x) for x in thislist]

赋值的时候,也有一些神奇的语法糖:

fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
newlist = []

newlist = [x for x in fruits if "a" in x]

#Equals to

for x in fruits:
  if "a" in x:
    newlist.append(x)
  
print(newlist)

更抽象地:

newlist = [expression for item in iterable if condition == True]

还是比较灵活的:

newlist = [x.upper() for x in fruits] 

支持直接排序。

thislist = ["orange", "mango", "kiwi", "pineapple", "banana"]
thislist.sort()
print(thislist)

排序也有一些参数。

thislist = [100, 50, 65, 82, 23]
thislist.sort(reverse = True)
print(thislist)

可以自定义估值函数,返回一个对象用于比较?

def myfunc(n):
  return abs(n - 50)

thislist = [100, 50, 65, 82, 23]
thislist.sort(key = myfunc)
print(thislist)

还有这样的:

thislist = ["banana", "Orange", "Kiwi", "cherry"]
thislist.sort(key = str.lower) #case insensitive
print(thislist)

所以其实排序内部可能是这样的:

if key(a) > key(b):
    a,b = b,a #swap the objects

翻转数组:

thislist = ["banana", "Orange", "Kiwi", "cherry"]
thislist.reverse()
print(thislist)

直接拷贝只能拷贝到引用,所以有拷贝数组:

thislist = ["apple", "banana", "cherry"]
mylist = thislist.copy()
print(mylist)

也可以直接构造:

thislist = ["apple", "banana", "cherry"]
mylist = list(thislist)
print(mylist)

合并:

list1 = ["a", "b", "c"]
list2 = [1, 2, 3]

list3 = list1 + list2
print(list3)

总结一下内置函数:

  • append,尾部追加。
  • clear,清空。
  • copy,生成副本。
  • count,数数用的。
  • extend,连接两个数组。
  • index,查找第一个满足条件的元素的下标。
  • insert,插入。
  • pop,按下标删除。
  • remove,按值删除。
  • reverse,翻转。
  • sort,排序。

元组(Tuple)

元组可以看作是不可修改的 List.

用圆括号包裹。

thistuple = ("apple", "banana", "cherry")
print(thistuple)

List 不同的是,单元素的元组声明时,必须加一个句号,否则不会识别为元组。

myList = ["list"]
myTuple = ("tuple") #not Tuple!
myRealTuple = ("tuple",) #is Tuple!
print(type(myList))
print(type(myTuple))
print(type(myRealTuple))

构造:

thistuple = tuple(("apple", "banana", "cherry")) # note the double round-brackets
print(thistuple)

元组是不可变的(immutable),想要修改只能变成 List,改完再生成元组。当然这样做效率很低。

x = ("apple", "banana", "cherry")
y = list(x)
y[1] = "kiwi"
x = tuple(y)

print(x)

当我们创建元组时,我们将变量填入,这被称为「打包(packing)」.

而我们也可以将元组重新解析为变量,这被称为「解包(unpacking)」.

fruits = ("apple", "banana", "cherry")
(green, yellow, red) = fruits

print(green)
print(yellow)
print(red)

有趣的是,元组不能修改,却能连接,这大概是因为运算过程产生了新的元组而作为返回值。

tuple1 = ("a", "b" , "c")
tuple2 = (1, 2, 3)

tuple3 = tuple1 + tuple2
print(tuple3)

fruits = ("apple", "banana", "cherry")
mytuple = fruits * 2 #interesting multiply <=> mytuple = fruits + fruits + ... times.

print(mytuple)

集合(Sets)

这个集合是数学意义上的集合,即具有无序性、不重复性、确定性的特性的集合。

用大括号:

thisset = {"apple", "banana", "cherry"}
print(thisset)

集合不支持下标访问,只能遍历:

thisset = {"apple", "banana", "cherry"}

for x in thisset:
  print(x)

不能修改元素,但可以添加元素。也可以删除再添加来达到修改的效果。

thisset = {"apple", "banana", "cherry"}

thisset.add("orange")

print(thisset)

简单的删除 remove,如果删除的元素不存在会报错。

thisset = {"apple", "banana", "cherry"}

thisset.remove("banana")

print(thisset)

如果不想要报错,可以用 discard

thisset = {"apple", "banana", "cherry"}

thisset.discard("banana")

print(thisset)

甚至可以用 pop,由于无序性,可能会随机删除一个元素?

thisset = {"apple", "banana", "cherry"}

x = thisset.pop()

print(x)

print(thisset)

取并集,也就是合并两个集合,需要使用 update,合并后会去重。

thisset = {"apple", "banana", "cherry"}
tropical = {"pineapple", "mango", "papaya"}

thisset.update(tropical)

print(thisset)

当然合并不仅限于集合之间。

thisset = {"apple", "banana", "cherry"}
mylist = ["kiwi", "orange"]

thisset.update(mylist)

print(thisset)

如果不想影响原集合,只需要返回值,可以用 union

set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}

set3 = set1.union(set2)
print(set3)

取交集:

x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}

z = x.intersection(y) #like union
x.intersection_update(y) #like update

print(x)

还有更有趣的,删去交集,即 \((\mathbb{A} \cup \mathbb{B}) \setminus (\mathbb{A} \cap \mathbb{B})\)

x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}

z = x.symmetric_difference(y)
x.symmetric_difference_update(y)

print(x)

清空和彻底删除:

thisset = {"apple", "banana", "cherry"}
thisset.clear()
print(thisset)
del thisset
print(thisset)

字典(Dictionary)

类似于 C++ 中的 map,键值对。

3.7 以上的 Python 版本中,字典是有序的。有序性、可变性、不重复性。

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
print(thisdict)
print(thisdict["brand"])
print(thisdict.get("model")) #the same with the former approach

有趣的是,值可以是任意数据类型。

thisdict = {
  "brand": "Ford",
  "electric": False,
  "year": 1964,
  "colors": ["red", "white", "blue"]
}

获取所有 key

x = thisdict.keys()

值得注意的是,这里传出的是一个引用,也就是说是可以动态更新的。但似乎是只读的。

car = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}

x = car.keys()

print(x) #before the change

car["color"] = "white"

print(x) #after the change

values 也是一样的:

car = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}

x = car.values()

print(x) #before the change

car["year"] = 2020

print(x) #after the change

还可以直接获取所有键值对 items

car = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}

x = car.items()

print(x) #before the change

car["year"] = 2020

print(x) #after the change

可以查看键是否存在:

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
if "model" in thisdict:
  print("Yes, 'model' is one of the keys in the thisdict dictionary")

可以用 update 来更新,支持塞入一个键值对集合:

thisdict = {
    "brand": "Ford",
    "model": "Mustang",
    "year": 1964
}
another = {
    "another": "Intersting",
    "stuff": "Join it"
}

thisdict.update({"year": 2020})
print(thisdict)
thisdict.update(another)
print(thisdict)

移除特定键:

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
thisdict.pop("model")
print(thisdict)

移除最后一个键值对:

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
thisdict.popitem()
print(thisdict)
thisdict.update({"new":"I'm newer"})
print(thisdict)
thisdict.popitem()
print(thisdict)

可以用 del 关键字:

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
del thisdict["model"]
print(thisdict)

清空:

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
thisdict.clear()
print(thisdict)

遍历所有键名:

for x in thisdict:
  print(x)

遍历所有值:

for x in thisdict:
  print(thisdict[x]) #have to search for the value each time executed

直接获取集合来遍历:

for x in thisdict.values():
  print(x)
for x in thisdict.keys():
  print(x)

遍历键值对:

for x, y in thisdict.items():
  print(x, y)

深拷贝:

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
mydict = thisdict.copy()
print(mydict)
mydict = dict(thisdict)
print(mydict)

嵌套:

child1 = {
  "name" : "Emil",
  "year" : 2004
}
child2 = {
  "name" : "Tobias",
  "year" : 2007
}
child3 = {
  "name" : "Linus",
  "year" : 2011
}

myfamily = {
  "child1" : child1,
  "child2" : child2,
  "child3" : child3
}

print(myfamily["child1"]["name"])

函数(Functions)

函数定义:

def my_function():
  print("Hello from a function")
my_function()

参数:

def my_function(fname):
  print(fname + " Refsnes")

my_function("Emil")
my_function("Tobias")
my_function("Linus")

形参(Parameter)和实参(Argument).

不定长参数:

def my_function(*kids):
  print("The youngest child is " + kids[2])

my_function("Emil", "Tobias", "Linus")

可以用更优雅的方式传参:

def my_function(child3, child2, child1):
  print("The youngest child is " + child3)

my_function(child1 = "Emil", child2 = "Tobias", child3 = "Linus")

实质上是键值对的传递,因此:

def my_function(**kid):
  print("His last name is " + kid["lname"])

my_function(fname = "Tobias", lname = "Refsnes")

默认参数:

def my_function(country = "Norway"):
  print("I am from " + country)

my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil")

弱类型,啥都能传:

def my_function(food):
  for x in food:
    print(x)

fruits = ["apple", "banana", "cherry"]

my_function(fruits)

返回值:

def my_function(x):
  return 5 * x

占位符:

def myfunction():
  pass

Lambda 表达式

只能有一行表达式,但可以有任意个数参数。

lambda arguments : expression

例如一个自增 \(10\) 的函数:

x = lambda a : a + 10
print(x(5))

多参数:

x = lambda a, b, c : a + b + c
print(x(5, 6, 2))

有趣的是,可以利用 Lambda 表达式构造匿名函数:

def myfunc(n):
  return lambda a : a * n

mydoubler = myfunc(2)
mytripler = myfunc(3)

print(mydoubler(11))
print(mytripler(11))

类和对象(Classes/Objects)

Python 是一个面向对象(Object Oriented)的语言。

class MyClass:
  x = 5

p1 = MyClass()
print(p1.x)

初始化:

class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

p1 = Person("John", 36)

print(p1.name)
print(p1.age)

声明方法:

class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def myfunc(self):
    print("Hello my name is " + self.name)

p1 = Person("John", 36)
p1.myfunc()

函数的第一个参数将会是指向自己的引用,并不强制命名为 self.

class Person:
  def __init__(mysillyobject, name, age):
    mysillyobject.name = name
    mysillyobject.age = age

  def myfunc(abc):
    print("Hello my name is " + abc.name)

p1 = Person("John", 36)
p1.myfunc()

可以删除某个属性:

del p1.age

可以删除对象:

del p1

占位符:

class Person:
  pass

继承(Inheritance)

class Person:
  def __init__(self, fname, lname):
    self.firstname = fname
    self.lastname = lname

  def printname(self):
    print(self.firstname, self.lastname)

#Use the Person class to create an object, and then execute the printname method:


x = Person("John", "Doe")
x.printname()


class Student(Person):
  def __init__(self, fname, lname, year):  # overwrite parent's __init__
    super().__init__(fname, lname)
    # <=> Person.__init__(self, fname, lname)
    self.graduationyear = year

  def welcome(self):
    print("Welcome", self.firstname, self.lastname,
          "to the class of", self.graduationyear)

  def printname(self):
      super().printname()
      print("plus {} is a student!".format(self.lastname))

x = Student("Mike", "Olsen", 2020)
x.welcome()
x.printname()

迭代器(Iterators)

一个迭代器需要有 __iter____next__ 两个方法。

所有的集合都能提供迭代器,都是可遍历的(Iterable Containers).

mytuple = ("apple", "banana", "cherry")
myit = iter(mytuple)

print(next(myit))
print(next(myit))
print(next(myit))

创建一个迭代器:

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration #Stop iterating

myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
  print(x)

定义域(Scope)

函数中声明的变量只在函数中有效。

def myfunc():
  x = 300
  print(x)

myfunc()

事实上,它在该函数的域内有效。

def myfunc():
  x = 300
  def myinnerfunc():
    print(x)
  myinnerfunc()

myfunc()

全局变量:

x = 300

def myfunc():
  print(x)

myfunc()

print(x)

更多有关全局变量的前文已经说过,这里复习一下。

x = 300

def myfunc():
  global x
  x = 200

def myfunc2():
  x = 400
  print(x)
  
myfunc()
myfunc2()

print(x)

模块(Modules)

调库大法好。

举个例子,在 mymodule.py 中保存以下内容:

person1 = {
  "name": "John",
  "age": 36,
  "country": "Norway"
}
def greeting(name):
  print("Hello, " + name)

然后在 main.py 中运行:

import mymodule

mymodule.greeting("Jonathan")
a = mymodule.person1["age"]
print(a)

可以起别名(Alias):

import mymodule as mx

a = mx.person1["age"]
print(a)

有一些内置的模块:

import platform

x = platform.system()
print(x)
x = dir(platform)
print(x)

可以指定引用模块的某些部分,此时不需要再写模块名:

from mymodule import person1
print (person1["age"])
#print(mymodule.person1["age"]) WRONG!!

也可以起别名:

from mymodule import person1 as p1
print (p1["age"])

PIP

包管理器。

安装包:pip install <package-name>
例如:pip install camelcase

然后就能直接使用了:

import camelcase

c = camelcase.CamelCase()

txt = "hello world"

print(c.hump(txt))

异常捕获(Try...Except)

比较常规。

try:
  print(x)
except NameError:
  print("Variable x is not defined")
except:
  print("Something else went wrong")
else:
  print("Nothing went wrong")
finally:
  print("Ended.")

举个例子:

try:
  f = open("demofile.txt")
  f.write("Lorum Ipsum")
except:
  print("Something went wrong when writing to the file")
finally:
  f.close()

抛出异常:

x = -1

if x < 0:
  raise Exception("Sorry, no numbers below zero")

可以指定类型:

x = "hello"

if not type(x) is int:
  raise TypeError("Only integers are allowed")

输入(Input)

很简单的输入。

username = input("Enter username:")
print("Username is: " + username)

格式化字符串(Formatting)

前文已经简单提及了。

price = 49
txt = "The price is {} dollars"
print(txt.format(price))

可以指定输出格式:

quantity = 3
itemno = 567
price = 49
myorder = "I want {0} pieces of item number {1} for {2:.2f} dollars."
print(myorder.format(quantity, itemno, price))

可以重复利用:

age = 36
name = "John"
txt = "His name is {1}. {1} is {0} years old."
print(txt.format(age, name))

可以传键值对:

myorder = "I have a {carname}, it is a {model}."
print(myorder.format(carname = "Ford", model = "Mustang"))

结语

差不多把 Python 中的基础语法过了一遍,相信各位读者读完后都能入门吧。

大部分编程概念都是相似的,学习起来并不困难。这也是一个写起来没什么心智负担的工具语言。有什么需要直接面向谷歌编程即可。

    原文作者:*Clouder
    原文地址: https://www.cnblogs.com/Clouder-Blog/p/python-tutorial.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系管理员进行删除。