后端学习笔记：Python基础

后端学习笔记：Python基础

数据类型：

Python中主要有以下几种常用的基本数据类型：

• String 字符串类型，用单引号或者双引号引用
• Number 数字类型，包括浮点数，整数，长整数和复数
• List 列表项，类似于数组
• Dictionary 字典，一个可变数据类型，加强版的Map，存储键值对类型
• Tuple 元组，相当于一个不可变的列表项

访问列表（元组）和字符串：

Python的列表访问和字符串访问很相似，均可以通过下标的形式访问，且支持前向访问和逆向访问，确定访问步长的特性。

Python中的列表项用[]确定，例如：

	hello = "Hello,Python!"
	helloList = []
	for char in hello:
	    helloList.append(char)
	print(hello)
	print(helloList)

这里声明的helloList变量就通过[]来确定其类型是List，不同于Java和Python中的列表，Python中的列表可以存储不同类型的数据变量，比如：

mutiList = ["name", "age", 18]
print(mutiList)

在访问列表时，可以通过前向和后向访问：

如图所示，前向访问和其他语言一致，从下标0开始递增；后向访问则从下标-1开始，依次递减。

我们还可以访问特定范围的元素，通过[起始范围：结束范围：步长（可选）]来访问（实际上是创建一个全新的列表）特定的范围：

hello = "Hello,Python!"
helloList = []
for char in hello:
    helloList.append(char)
# [起始下标：结束下表]
print(helloList[0:5])
# [起始下标：结束下表：步长]
print(helloList[0:11:2])
# [起始下标:结束下标（反向访问）]
print(helloList[-8:-1])
print(helloList[0:-2])

输出结果为：

拓展列表

除此之外，我们还可以通过 *，+ 操作符来拓展列表，*代表的是原序列的重复，+来拼接新的内容，比如说：

hello = "Hello,Python!"
helloList = []
for char in hello:
    helloList.append(char)
print(helloList * 2)
print(helloList + ["!", "!"])

输出结果为：

字符串的访问

实际上来说对于字符串的访问和列表的访问基本上是一致的，我们可以通过列表项的访问方式来访问字符串。

helloList = "Hello,Python!"
# helloList = []
# for char in hello:
#     helloList.append(char)
# [起始下标：结束下表]
print(helloList[0:5])
# [起始下标：结束下表：步长]
print(helloList[0:11:2])
# [起始下标:结束下标（反向访问）]
print(helloList[-8:-1])
print(helloList[0:-2])
print(helloList * 2)
print(helloList + "!!")

结果：

元组的访问

元组用()标识。
元组的访问也是一致，但是由于元组不可变，所以拓展语句对其无效：

tuple = ("a","b","c","d","e")
print(tuple[0:6])
print(tuple[0:6:2])
print(tuple[0:-1])

结果：

访问字典

字典通过{}来表示。

对于字典的访问和Kotlin中的Map的访问类似，都是通过get方法来访问，get方法重载符是[]比如说dic.get(key) 就可以写成 dic[key];典型例子:

	namebook = { "Name" : "Alex", "Age" : 18 , "Class" : "First" }
	print(namebook.get("Name"))
	# 只读Key
	for key in namebook:
	    print(key, namebook[key])
	# 同时读KV
	for key,value in namebook.items():
	    print(key, value)

条件控制语句

条件语句

首先是if条件语句，由if语句，elif语句，else语句组成，就相当于其它语言中的if，else if，else语句一样：

	str = ""
	str += input()
	if str == "a":
	    print("A")
	elif str == "b":
	    print("B")
	elif str == "c":
	    print("C")
	else:
	    print("not match")

需要说明的是，Python没有原生的switch case语句，不过Python3.1中引入了match语句，类似于switch case语句，不同的是其用case _代表任何项都不匹配的情况：

str = ""
str += input()
match(str):
    case "a": print("match a")
    case "b": print("match b")
    case "c": print("match c")
    case _: print("not match")

循环语句

循环语句分为for循环和 while循环，for循环可以遵循类似Kotlin中的for循环，创建一个范围类为循环的范围：

for a in range(0,5):
    print(a)

while循环就如下：

b = 0
while b < 5:
    b += 1
    print("repeat..."+ str(b))

同时我们可以用break关键字和continue关键字来控制循环,他们的作用和其他语言是一致的：

for a in range(0,5):
    if (a == 3): continue
    print(a)

b = 0
while b < 5:
    b += 1
    if (b == 3): break
    print("repeat..."+ str(b))

结果如下：

函数定义&调用

Python中用def来声明一个函数。

Python中的函数定义比较简单（因为它是脚本语言），只要确定函数名和参数列表即可，Python 采用鸭子类型哲学，即只要一个对象具有所需的方法或属性，就可以使用它，而不关心对象的具体类型。这种方式让代码更加灵活和通用。

同时，这种特性可以让我们实现曾经的非脚本语言无法做到的事情：“一个函数可以返回多种数据类型”：

def sayHello():
    print("hello python")

def mutiReturnType(clazz):
    match(clazz):
        case "String": return "string"
        case "Number": return 1
        case "List": return [1,2,3,4,5]
        case _: print("not match")

sayHello()
clazz = input()
result = mutiReturnType(clazz)
print(result)

在上述片段中，mutiReturnType函数就可以返回四种类型的参数。

默认参数值

和Kotlin一样，Python中的函数也可以使用默认参数值：

def defaultParaMethod(a = 10, b = 11, c = 12, d = 13):
    print(a,b,c,d)

这样我们在调用时就可以避免传入一些我们不关心的参数，我们可以这样调用：

defaultParaMethod(d = 16)

函数的参数传递

关于Python的参数传递大致遵循C语言的原理，对于不可变参数，采取值传递；对于可变参数则是采取引用传递，比如可以通过下边的示例来理解：

def passingParam(str = "", int = 0, list = [], dic = {}):
    if (len(str) > 0):  str *= 2
    elif (int != 0):  int *= 2
    elif (len(list) > 0):  list *= 2
    elif (len(dic) > 0): dic["sp"] = 22


# string
print("===================string=====================")
para = "abc"
result = passingParam(str = para)
print(para)

# int
print("===================int=====================")
para = 11
result = passingParam(int = para)
print(para)
# list
print("===================list=====================")
para = [1,2,3]
result = passingParam(list = para)
print(para)
# dic
print("===================dic=====================")
para = {"gender":"man", "age":16}
result = passingParam(dic = para)
print(para)

结果如下：

不定长参数

在Python中，我们可以通过在参数名前加上*来声明一个不定长参数，访问参数的手段也和其他语言大同小异，采取列表的访问形式即可：

def biggestNumber(*numbers):
    biggest = numbers[0]
    for number in numbers[1:]:
        if number > biggest:
            biggest = number
    return biggest

bigNumber = biggestNumber(-1,5,6,10,-9,105)
print("biggest", bigNumber)