Python基本语法

一 基础知识

1. 注释

单行注释：#注释内容
多行注释：'''注释内容'''

PS：python2中，如果程序使用到中文，需要在程序的开头加上这段代码：#coding=utf-8；
而python3则不需要，是默认支持中文格式的

2. 变量

#变量的定义
例如：num = 10
不需要像Java一样显示的给变量声明类型，系统会根据变量的值自动判断变量的类型，可以通过 type(变量名) 获取变量类型

#变量的类型
Numbers（数字）：int long float complex（复数）
bool（布尔）：True False （注意是大写）
String（字符串）：name = "sangfor"（单引或双引都可以）
List（列表）：name = [1,2,3]（列表中的元素可以重复、可以修改、可以存放不同类型的值）
Set（集合）：name = {1,2,3}（集合中的元素不可以重复、可以修改、可以存放不同类型的值）
Tuple（元组）：name = (1,2,3)（元组中的元素可以重复、不可以修改、可以存放不同类型的值）
Dictionary（字典）：name = {"age":18,"sex"："男"}

3. 输入与输出

#格式化输出
name = "sangfor"
age = 20
printf("姓名是：%s" %name)
printf("姓名是：%s，年龄是：%d" %(name,age))

#format格式化输出
#相对基本格式化输出采用‘%’的方法，format()功能更强大，该函数把字符串当成一个模板，通过传入的参数进行格式化，并且使用大括号‘{}’作为特殊字符代替‘%’
 1 >>> print('{} {}'.format('hello','world'))  # 不带字段
 2 hello world
 3 >>> print('{0} {1}'.format('hello','world'))  # 带数字编号
 4 hello world
 5 >>> print('{0} {1} {0}'.format('hello','world'))  # 打乱顺序
 6 hello world hello
 7 >>> print('{1} {1} {0}'.format('hello','world'))
 8 world world hello
 9 >>> print('{a} {tom} {a}'.format(tom='hello',a='world'))  # 带关键字
10 world hello world

#输入
python3中使用input()函数
例如：
name = input("请输入姓名：") 
print(name)

4. 运算符

#算术运算符的优先级
** 高于 * / % // 高于 + -
PS：不同类型进行运算，会转换成浮点型

#赋值运算符
例如：num += 10 等价于 num = num + 10
支持多个变量赋值：num1,numu2,num3 = 1,2,"aa"

5. 数据类型转换

#把变量a默认按10进制转换成int类型
num = int(a)
#把字符串按8进制转换成int类型，结果为8
num = int("10",8)
#把浮点数3.7转换成int类型，结果为3（直接舍去小数部分）
num = int(3.7)
#创建一个复数
num = complex(10,4) 等价于 num = 10 + 4j
#将序列转换为列表
s = (1,2,3)
num = list(s) 等价于 num = [1,2,3] 

二 循环语句和判断语句

#循环语句模板（注意有冒号）
if XXX1：
	print("XXX")
elif XXX2：
	print("XXX")
else:
	print("XXX")

#while循环举例（注意有冒号）：
i = 5
while i > 0:
    print(i)

#for循环模板（注意有冒号）：
for 临时变量 in 字符串或列表或元组或字典等可以迭代的对象:

#关系运算符
==、！=、>、<、>=、<=

#逻辑运算符
and、or、not

三 字符串

#字符串的切片
语法：[起始下标：终止下标：步长]
注意：左闭右开，步长默认为1，不指定起始下标，则起始默认为0，不指定终止下标，则默认最后一个元素
例如：
name = "abcde"
print(name[0:3]) #abc
print(name[:3]) #abc
print(name[3:]) #de
print(name[1:-1]) #bcd
print(name[::2]) #ace
print(name[::-1]) #edcba
print(name[4:1:-1]) #edc

#字符串常见操作
1. find
name = "abcde"
print(name.find("cde")) #存在返回起始下标，2
print(name.find("cde"，0,4)) #不存在返回-1，注意是左闭右开

2. index：功能与find一样，只不过找不到值的时候会抛出异常

3. count：统计出现的次数
name = "hello,hi,hello"
print(name.count("hello")) #返回2

4. replace：替换，可以指定替换的次数
name = "hello,hi,hello"
num = name.replace("he","HE",1)
print(num) #结果为：HEllo,hi,hello

5. split：根据指定的分隔符切分为多个元素，存放在list中
name = "ab c d"
print(name.split(" ")) #['ab','c','d']

6. 
startswith：判断是否以指定字符串开头，是返回True，否则返回False
endswith：判断是否以指定字符串结尾，是返回True，否则返回False
name = "hello"              
print(name.startswith("he")) #True   
print(name.endswith("lo")) #True  

四 列表

#使用for循环遍历列表
name = ["a","b","c"]
for i in name:
    print(name)
    
#使用while循环遍历列表
name = ["a","b","c"]
lens = len(name)
i = 0
while i < lens:
    print(name)
    i += 1

#列表的常见操作
[一]添加操作
1.append：追加操作
name = ['a','b']
name.append("c")
print(name) #['a','b','c']

2.extend：将一个列表中的元素逐一添加到另一个列表中
3.insert：将某个元素插入到指定下标之前

[二]修改元素：可以通过下标指定修改哪个元素
name = ['a','b']
name[0] = "c"
print(name) #['c','b']

[三]查找元素：in、not in
name = ['a','b']
if "a" in name:
    print("yes") #yes
    
[四]删除元素
1. del：根据下标删除元素
2. pop：删除最后一个元素
3. remove：根据元素值删除

例如：
name = ['a','b']
del name[0]
name.pop()
name.remove("a")

PS:注意三者的区别

[五]排序和逆序
1. name.sort()
2. name.reverse()

五 元组

元组的操作与列表类似，不同之处在于元组中的元素不能修改，即定义好的元组只能遍历、查找，无法插入、删除、update，元组也没有提供相应的方法供我们操作

name = (1,2,3)
name[0] = 4 #执行此语句，程序会报错

六 字典

字典类似于Java中的Map，存放的是键值对

#根据键访问值
info = {"name":"sangfor","age":20}
print(name["name"]) #输sangfor
print(name["sex"])  #访问不存在的键，会报错

#通过get方法访问，如果键不存在，则返回None，不会报错
print(name.get("age")) #输出20
print(name.get("sex")) #访问不存在的键，输出None
print(name.get("sex"，18)) #访问不存在的键，设置了默认值，输出默认值18

#修改元素
info = {"name":"sangfor","age":20}
info["name"] = "ccj"
print(info) #{"name":"ccj","age":20}

#添加元素（如果修改的元素不存在，就相当于新增）
info = {"name":"sangfor","age":20}
info["sex"] = "男"
print(info) #{"name":"ccj","age":20,"sex":"男"}

#删除元素
info = {"name":"sangfor","age":20}
del info["name"] #删除指定元素，也可以是del (info["name"])
print(info) #{"age":20}
info.clear() #清空元素
print(info) #{}

#字典的常见操作
info = {"name":"sangfor","age":20}
[1]len：求字典的键值对数量
print(len(info)) #2

[2]keys：返回一个包含所有key的列表
print(info.keys()) #['name','age']

[3]values：返回一个包含所有value的列表
print(info.values()) #['sangfor',20]

[4]items：返回一个包含所有键值对（元组）的列表
print(info.items()) #[('sangfor',20),("age":20)]

#字典的遍历
info = {"name":"sangfor","age":20}
[1]遍历字典的键
for key in info.keys():
    print(info[key])
[2]遍历字典的项
for item in info.items():
    print(item)
[3]遍历字典的key、value
for key,value in info.items():
    print("key=%s,value=%s" %(key,value))

七 集合

集合一般用于列表、元组的去重，将一个带有重复元素的列表或者元组转换成集合，就可以实现去重

#去重
age = [1,2,2]
temp = set(age)
print(temp) #{1,2}

#添加元素
add方法

#把一个可迭代的对象逐一添加到集合中，参数必须是字符串、列表等可以迭代的对象
update方法

#删除元素
[1]remove：删除指定值，没有该值会报错
[2]pop：随机删除一个元素
[3]discard：删除指定值，没有该值不会报错

#集合的交集和并集
[1]交集：&
[2]并集：|

八 可迭代对象的公共方法和内置函数

[1]合并：+
[2]复制：*
[3]存在：in
[4]不存在:not in
    
#python四个内置函数
[1]len(item)
[2]max(item)
[3]min(item)
[4]del(item)
PS：del删除元素有两种用法，一种是加空格，一种是加括号

#多维列表/多维数组的访问
tuple = ((1,2),(3,4))
print(tuple[0]) #(1,2)
print(tuple[0][1]) #2
print(tuple[0][2]) #程序报错

九 函数

1. 全局变量和局部变量

[1]下面这种方式是在方法内定义了一个同名局部变量，并不是修改局部变量的值
name = 11 #全局变量
def test():
    name = 22 #局部变量
    
[2]如果要修改全局变量的值，可以先通过“global 全局变量”进行声明
name = 11 #全局变量
def test():
    global name
    name = 22 #修改全局变量的值

2. 一个函数返回多个值

例如：
return a,b     #默认以元组的形式展示
return {1,2,3} #返回一个集合
return [1,2,3] #返回一个列表

3. 缺省参数

（带有默认值的参数要放在参数列表的最后面）

def test(a,b=10):
    print(a)
    print(b)
test(11) #调用函数，没给声明了默认值的参数赋值时，会自动使用默认值

4. 拆包

def test():
    return 10,20
print(test()) #(10,20)
res1,res2 = test()
print(res1) #10
print(res2) #20

#还可以对元组、列表进行拆包
a,b = [1,2]
a,b = {"name":"ccj","age":18}

5. 可变类型和不可变类型

可变类型：列表、集合、字典
不可变类型：数字、字符串、元组

例如：
[1]不可变类型
a = 1
b = a
a = 2
print(b) #1

[2]可变类型
num = [1,2]
temp = num
num.appemd(3)
print(temp) #[1,2,3]

注意：python中没有方法重载的概念，因此函数名不可以相同

十 异常

[1] 模板一：

try:
	XXX
except Exception as result:
    print(reslut)
else:
    print("没有异常")
    
[2] 模板二：

try:
	XXX
except Exception as result:
    print(reslut)
finally:
    print("不管有没有异常，一定会执行")

十一 模块

#引入整个模块
import 模块名
from 模块 import *

#引入某个模块的某个函数
from 模块 import 函数

#可以通过__name__这个变量的值来判断是直接执行的python脚本还是被引入执行的，从而有选择性的执行测试代码
#如果是直接执行的python脚本，则取值为'__main__'，如果是引入执行的，则结果为脚本的名字
例如：
if __name__ = '__main__':
    执行测试代码

十二 面向对象

1. 类和对象

类名的命名规则是大驼峰命名法

类中的实例方法的第一个参数为self，表示实例对象本身，可以通过它来访问类的属性（self可以替换成其他名）

#python定义类的模板：
class Test(object):
    def test(self):
        print("XXX")
#创建对象
对象名 = 类名()

2. 魔法方法

[1]__init__：类似于java中的无参构造方法，一般用于变量的初始化和赋值
[2]带参数__init__：类似于java中的有参构造方法，一般用于变量的初始化和赋值
[3]__str__：类似于java中的toString方法，一般用于打印类的信息，没有声明该方法，那么默认打印的是对象的内存地址信息
[4]__del__：当删除对象时会自动调用的一个方法（del(对象名)）

3. 继承

python中类支持多继承，如果继承的多个类出现同名方法或属性，那么默认调用的是第一个类，也就是声明在前面的类

#单继承模板
class A(object):
    def test(self):
        print("XXX")
class B(A):
    pass
b = B()
b.test() #XXX

#多继承模板
class A(类1,类2)

如果子类和父类出现同名方法，则默认执行的是子类的方法，要调用父类的方法可以通过“父类类名.方法()”或者“super().方法()"

4. 私有属性和方法

python中没有private等访问权限修饰符，在属性或方法名前面加上__就代表是私有的

十三 文件操作

#文件的写操作
f = open("../resources/a.txt","w")
f.write("hello")
f.close()

#文件的读操作
f = open("../resources/a.txt","r") #r可以省略，文件默认就是只读操作
res = f.read() #读取出所有文件
print(res) #hello

#如果文件中涉及到中文，则需要加上编码设置，避免乱码
f = open("../resources/a.txt",encoding = "utf-8")

#python读取json文件中的数据
import json #涉及json操作需要导入该模块
f = open("../resources/a.json",encoding = "utf-8")
res = f.read()
print(type(res)) #字符串类型
json.loads(res) #把json格式的字符串转换成python中的字典类型，就可以通过操作字典的语法来获取数据

注意：如果json文件的数据有误，那么json.loads()方法会把报错，类似的，json.dumps()方法的作用是将python中的字典类型转换成json格式的字符串

十四 其它操作

1. for循环获取下标值

name = []
name.append("a")
name.append("b")
name.append("c")
for index, value in enumerate(name):
    print(index, value)

输出结果为：
0 a
1 b
2 c

2. python构造方法与java构造方法的区别

• 在java中，子类必然会调用父类的构造方法，要么是你显式调用，要么是Java自动调用。如果开发者没有手动调用父类的构造方法，那么在创建子类对象时会默认自动调用父类的无参构造方法；也就是说如果父类有不带参数的构造方法，或者父类没有任何构造方法（也就是说有缺省构造方法），那么子类可以不显式调用，子类会自动调用super()；如果父类有带参数的构造方法，却没有不带参数的构造方法，那么如果子类没有显式调用父类构造方法，那么编译会报错。
• 在python中，子类不会自动调用父类的构造函数，必须显示调用。如果子类和父类都有构造函数，子类其实是重写了父类的构造函数，如果不显式调用父类构造函数，父类的构造函数就不会被执行，导致子类实例访问父类初始化方法中初始的变量就会出现问题。

虽然python和java一样都是面向对象，但还是有一些差别，构造函数就是一个最好的例子。