学习Python基础语法day01

1.Python标识符

• 组成：数字，字母，下划线
• 所有标识符可以包括英文，数字以及下划线，但是不能以数字开头
• 区分大小写
• 以下划线开头的标识符是具有特殊意义的，如以单下划线开头_foo的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用from xxx import*而导入
• 以双下划线开头的__foo代表类的私有成员，以双下划线开头和结尾的__foo__代表Python里特殊方法专用的标识，如__init__()代表类的构造函数
• python可以同一行显示多条语句，方法是用分号分开

2.python关键字

and	exec
not	assert
finally	or
break	for
pass	class
from	print
continue	global
raise	def
if	return
del	import
try	elif
in	while
else	is
with	except
lambda	yield

3.行、缩进、引号、注释、空行

3.1缩进规则

• python里面不用{}控制类，函数，以及其他逻辑判断
• 缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量

3.2多行语句

# 多行语句:用反斜杠来连接
item_one = 0
item_two = 2
item_three = 3
total = item_one + \
    item_two + \
    item_three
print(total)    # 5

注意点：

• 如果包含[],{},()括号就不需要用多行连接符，如下述例子

# 在[],{},()中的多行语句,不需要使用反斜杠(\)
total = ['item_one', 'item_two', 'item_three']
print(total)     # ['item_one', 'item_two', 'item_three']

3.3引号

可以使用单引号，双引号，三引号来表示字符串，引号的开始和结束必须是相同类型的，其中三引号可以有多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释

3.4注释

• 单行注释用#开头
• 多行注释请看下述例子

'''
这是多行注释
'''

3.5python空行

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始，类和函数入口之间也用一行空行分隔，以突出函数入口的开始
注意点：
空行不是python语法的一部分，书写时不插入空行，python解释器也不会运行出错，但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构

4.输入、输出

4.1输入

n = input()

4.2输出

x = "a"
y = "b"
# 换行输出
print(x)
print(y)
print("---------")
# 不换行输出
print(x),
print(y),
print(x, y)

5.多个语句构成代码组

缩进相同的一组语句构成一个代码块，我们称之为代码组，像if，while，def和class这样的复合语句，首行以关键字开始，以冒号结束，该行之后的一行或多行代码构成代码组

score = 80
if score >= 90:
    print('A')
elif score >= 80:
    print('B')
elif score >= 70:
    print('C')
elif score >= 60:
    print('D')
else:
    print('E')

6.python基本数据类型

6.1.单变量赋值

python中的变量不需要生命，每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建

a = 100  # 整型变量
b = 100.0  # 浮点型变量
c = 'abc'  # 字符串

6.2.多变量赋值

# 以下实例，创建一个整型对象，值为1，从后向前赋值，三个变量被赋予相同的数值
a = b = c = 1
# 以下实例，两个整型对象1和2的分配给变量a和b，字符串对象‘abc’分配给变量c
a, b, c = 1, 2, 'abc'
print(a, b, c)  # 1 2 abc

6.3.标准数据类型

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictonary（字典）

注意点：
（1）不可变数据（三个）：Number（数字），String（字符串），Tuple（元组）
（2）可变数据（3个）：List（列表），Dictionary（字典），Set（集合）

6.3.1.Number（数字）

注意点：
数据类型是不允许改变的，如果改变数字数据类型的值，将重新分配内存空间
（1）支持四种类型：

• int：表示为长整型，没有long
• float
• bool
• complex（复数）：a+bj复数的实部a和虚部b都是浮点型

（2）注意点：

• python2中没有布尔型，0表示false，1表示true
• python3中，True和False是关键字，但他们的值仍是0个1，可以进行数字相加

（3）用一个函数可以用来查看变量所指的对象类型，用isinstance也可以判断，例如：

a, b, c = 1, 2, 'abc'
print(a, b, c)  # 1 2 abc
# 查看变量所指的对象类型
print(type(a))   # 
print(type(b))   # 
print(type(c))   # 

print(isinstance(a, int))  # True

注意点：isinstance和type的区别在于

• type（）不会认为子类是一种父类类型
• isinstance（）会认为子类是一种父类类型

（4）可以使用del语句删除一些对象引用，例如：

del a
del b，c

（5）数值运算

print(1 + 1)  # 加法 2
print(1.1 - 1)  # 减法 0.10000000000000009
print(2 * 3)   # 乘法 6
print(2 / 4)  # 除法 0.5
print(2 // 4)  # 除法：得到一个整数 0
print(7 // 2.0) # 3.0
print(7.0 // 2) # 3.0
print(10 % 3)  # 取余 1
print(2 ** 3)  # 乘方 8

注意点：

• /返回一个浮点数,//返回一个整数（直接舍弃其后的小数）
• 在混合运算时，python会把整型转换成为浮点数
• *表示乘法，**表示乘方

（6）数据类型转换

• int（x）：将x转换为一个整数
• float（x）：将x转换得到一个浮点数
• complex（x）：将x转换得到一个复数，实数部分为x，虚数部分为0
• complex（x，y）：将x和y转换得到一个复数，实数部分为x，虚数部分为y，x和y是数学表达式

a = 1.5
print(int(a))  # 1
a = 1
print(float(a))  # 1.0  
print(complex(a))  # (1 + 0j)
print(complex(a,1))  # (1 + 1j)

(7)数学函数

函数	返回值（描述）
abs（x）	返回数字的绝对值
ceil（x）	向上取整
cmp（x，y）	如果xpython3已废弃，使用（x>y） - (x
exp（x）	返回x次幂，math.exp（1）返回2.718281828459045
fabs（x）	返回数字的绝对值，math.fabs(-10)，返回10
floor（x）	向下取整，math.floor(4.9)返回4
log（x）	math.log(math.e)返回1.0，math.log（100,10）返回2.0
log10(x)	返回以10为基数的x的对数，math.log10(100)返回2.0
max(x1,x2…)	返回给定参数的最大值，参数可以为序列
min(x1，x2…）	返回给定参数的最小值，参数可以为序列
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示
pow(x,y)	x**运算后的值
round(x,[n])	返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数
sqrt（x）	返回数字x的平方根

import math
a = -1.9
b = 2
c = -3
d = -1.9
list = [-1.9, 2, -3, -1.9]
print(abs(a))  # 1.9
print(math.ceil(a))  # -1
print((a > b) - (a < b))  # -1
print((a > c) - (a < c))  # 1
print((a > d) - (a < d))  # 0
print(math.exp(1))    # 2.718281828459045
print(math.fabs(a))   # 1.9
print(math.floor(a))  # -2
print(math.log(math.e))  # 1.0
print(math.log(100, 10))  # 2.0
print(math.log10(100))  # 2.0
print(max(a, b, c, d))  # 2
print(max(list))  # 2
print(min(a, b, c, d))  # -3
print(min(list))  # -3
print(math.modf(a))  # (-0.8999999999999999, -1.0)
print(math.pow(2, 3))  # 8.0
print(round(a))  # -2
print(math.sqrt(16))  # 4.0

（8）随机数函数

函数	描述
choice(range(10))	从序列的元素中随机挑选一个元素，比如random.choice(range(10)),从0到9中随机挑选一个整数
randrange([start,]stop[,step]	从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为1
random()	随机生成下一个实数，它在[0,1)范围内
seed([x])	改变随机数生成器的种子
shuffle(list）	将序列的所有元素随机排序
uniform(x，y)	随机生成下一个实数，它在[x,y]范围内

import random
print(random.choice(range(100)))  # 66
list = [-1.9, 2, -3, -1.9]
random.shuffle(list)
print(list)  # [2, -1.9, -3, -1.9]
print(random.uniform(10, 20))  # 13.003644396627625

6.3.2.String（字符串）

（1）截取字符串

• 加号+是字符串的连接符
• 星号*表示复制当前字符串，与之结合的数字为复制的次数

str = 'helloworld'
print(str)  # 输出字符串 helloworld
print(str[0: -1])  # 输出第一个到倒数第二个的所有字符 helloworl
print(str[0])  # 输出字符串第一个字符 h
print(str[2: 5])  # 输出从第三个字符到第五个的字符 llo
print(str[2:])  # 输出从第三个开始的后的所有字符 lloworld
print(str * 2)  # 输出字符串两次 helloworldhelloworld
print(str + "test")  # 连接字符串helloworldtest

（2）转义
如果你不想让反斜杠发生转移，可以在字符串前面添加一个r，表示原始字符串，例如

print('hello\nworld')
print(r'hello\nworld')

输出结果：

（3）理解python字符串之不可变
向一个索引赋值，比如word[0] = 'm'会导致错误，若实在想更新字符串，则可以借助截取和+两种操作结合，例如：

str = "hello world!"
print(str[0:6] + "lyh")  # hello lyh

（4）python字符串运算符

+	字符串拼接
*	重复输出字符串
[]	通过索引获取字符串中字符
[:]	截取字符串中的一部分，左闭右开原则
in	成员运算符，如果字符串中包含给定的字符返回True
not in	成员运算符，如果字符串中不包含给定的字符返回False
r/R	原始字符串-原始字符串
%	格式字符串

（5）字符串格式化

print("我叫%s今年%d岁！" % ('lyh', 21))  # 我叫lyh今年21岁！

符号	描述
%c	格式化字符及其ASCII码
%d	格式化字符串
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
% f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e
% g	%f和%e的简写
%G	%f和%E的简写
%p	用十六进制数格式化变量的地址

6.3.3.List（列表）

• 列表中的元素类型可以不相同
• 字符串甚至可以包含列表（嵌套）
• 列表是写在方括号[]之间，用逗号分隔开的元素列表
• 可以被索引，截取和拼接
• 列表元素可变
• List写在方括号之间，元素之间用逗号隔开
• 可以使用+操作符进行拼接

list = ['abcd', 777, 3.2, 'rt', 90]
list2 = [90]
print(list)  # ['abcd', 777, 3.2, 'rt', 90]
print(list[0])  # abcd
print(list[1: 3])  # [777, 3.2]
print(list * 2)  # ['abcd', 777, 3.2, 'rt', 90, 'abcd', 777, 3.2, 'rt', 90]
print(list + list2)  # ['abcd', 777, 3.2, 'rt', 90, 90]

def reverseWords(input):
    # 通过空格将字符串分隔符，把各个单词分隔为列表
    inputWords = input.split(" ")

    # 翻转字符串
    # 假设列表 list = [1,2,3,4],  
    # list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样)
    # inputWords[-1::-1] 有三个参数
    # 第一个参数 -1 表示最后一个元素
    # 第二个参数为空，表示移动到列表末尾
    # 第三个参数为步长，-1 表示逆向
    inputWords = inputWords[-1::-1]

    # 重新组合字符串
    output = ' '.join(inputWords)

    return output


if __name__ == "__main__":
    input = 'I like runoob'
    rw = reverseWords(input)
    print(rw)

6.3.4.Tuple(元组）

• 与列表类似
• 元素不能更改
• 也可以截取
• 元素写在小括号()里,元素之间用逗号隔开
• 字符串可以看为特殊的元组
• 元组也可以被索引和切片，方法一样
• 元组也可以使用+操作符进行拼接

tuple = ('abcd', 777, 3.2, 'rt', 90)
tuple2 = (90, 2)
print(tuple)  # ('abcd', 777, 3.2, 'rt', 90)
print(tuple[0])  # abcd
print(tuple[1: 3])  # (777, 3.2)
print(tuple * 2)  # ('abcd', 777, 3.2, 'rt', 90, 'abcd', 777, 3.2, 'rt', 90)
print(tuple + tuple2)  # ('abcd', 777, 3.2, 'rt', 90, 90)

注意点：

• 虽然tuple的元素不可变，但它可以包含可变的对象，比如list列表
• 构造包含0个或1个元素的元组比较特殊，所以有一些额外的语法规则

tuple1 = ()   # 空元组
tuple2 = (1,) # 一个元素，需要在元素后添加逗号

• string，list和tuple都属于sequence（序列）

6.3.5.Set集合

• 不包含重复元素
• 创建一个空Set用（）
• 无序的

# 第一种创建方法
arr = {
     12, 12, 34, 'ab', 'ab', 'ac'}
print(arr)  # 输出集合,重复的元素被自动去掉 {34, 12, 'ac', 'ab'}
# 第二种创建方法
a = set('11222345')
print(a)  # {'2', '3', '5', '1', '4'}

• set的集合运算

# set的集合运算
print(a)  # {'2', '3', '5', '1', '4'}
print(b)  # {'7', '4', '5', '2'}
print(a - b)  # a和b的差集 {'3', '1'}
print(a | b)  # a和b的并集 {'7', '4', '1', '5', '2', '3'}
print(a & b)  # a和b的交集 {'4', '5', '2'}
print(a ^ b)  # a和b中不同时存在的元素 {'7', '1', '3'}

6.3.6.Dictionary（字典）

• 是python中另一个非常有用的内置数据类型
• 列表是有序的对象集合，字典是无序的对象集合
• 字典当中的元素是通过键来存取的，而不是通过偏移存取
• 是一种映射类型，字典用{}标识，它是一个无序的键（key）：值（value）的集合
• 键（key）必须使用不可变类型
• 在同一个字典中，键（key）必须是唯一的
• 字典是一种映射类型，它的元素是键值对
• 字典的关键字必须为不可变类型，且不能重复
• 创建空字典使用{}

user = {
     
    'name': 'Tom',
    'age': 18,
    'sex': 'male'
}
print(user)    # {'name': 'Tom', 'age': 18, 'sex': 'male'}
print(user['age'])  # 18

user['age'] = 28
print(user)  # {'name': 'Tom', 'age': 28, 'sex': 'male'}

# 可以通过赋值的方式给字典里面添加元素
user['fav'] = '打篮球'
print(user)   # {'name': 'Tom', 'age': 28, 'sex': 'male', 'fav': '打篮球'}

dict = {
     }
dict['one'] = "lyh"
dict[2] = "liyuhuan"

tinydict = {
     'name': 'liyuhuan', 'sex':'女', 'age': 21}

print(dict['one'])       # 输出键为 'one' 的值  lyh
print(dict[2])           # 输出键为 2 的值   liyuhuan
print(tinydict)          # 输出完整的字典   {'name': 'liyuhuan', 'sex': '女', 'age': 21}
print(tinydict.keys())   # 输出所有键   dict_keys(['name', 'sex', 'age'])
print(tinydict.values())  # 输出所有值   dict_values(['liyuhuan', '女', 21])