1.1、Python基础-注释、变量声明及命名规则、数据类型

Python基础

1、注释

注释是给程序员看的，为了让程序员方便阅读代码，解释器会忽略注释。使用自己熟悉的语言，适当的对代 码进行注释说明是一种良好的编码习惯。

注释写法

#我是单行注释

'''
我是多行注释
'''
1
2
3
4
5

2、变量

命名规则：在Python中，通常采用下划线分隔的命名风格，这也被称为蛇形命名法（Snake Case）。这意味着变量名中的单词用下划线分隔，所有字母都小写，例如user_name。

声明变量时，不需要指定变量类型，直接写变量名和值就行了。

user_name = "zhangsan"
print(user_name)
1
2

3、数据类型

python有七大数据类型：
（1）数字（Number）：int(整型，长整型)，float(浮点型)，complex(复数）
（2）布尔（Boolean）：True,False
（3）字符串(String)：“Python”，‘python’
（4）列表（List）：[1,2,3,4]，[1,2,3,[1,2,3],"hello”]
（5）字典（Dictionary）:{1:"hello",2:"world"}
（6）元组（Tuple）：（1,2,3，“hello”,"world"）
（7）集合（Set）:{1,2,3，“hello”}
注：也有说python有六大数据类型，其中把布尔型放在了数字类型中。
不可变类型有4个：数字、布尔、字符串、元组
可变类型有3个：列表、字典、集合
可变数据类型是指内容可以随着函数的执行发生变化
不可变数据类型则是从初始化到结束都是不可改变的

3.1、数字（Number）

3.1.1、 int（整形）

在python之中将整型和长整型合在了一起，在python3中只有int，没有long

import sys
#获取系统支持的最大整形
print(sys.maxsize)
i=9
print(i)
1
2
3
4
5

3.1.2、 float (浮点型）

浮点数可以用小数点的形式表示， 也可以用科学技术法的形式表示（可以用e或者E，E与e的含义相同，都是表示10的多少次方）
列如：i = 7e2 （7e2代表7乘以10的2次方），此时i= 700

m = 0.01
n = 5e3

print('m=',m,'n=',n)#m= 0.01 n= 5000.0
1
2
3
4

3.1.3、 complex（复数）

用的很少，不说了

3.2、布尔（Boolean）

布尔类型是只有True和False两种值（注意单词首字母要大写）的数据类型。
常用的布尔运算包括and、or、not三种，布尔类型值可以相加，但一旦相加，类型就会转换为int类型，True表示1，False表示0

x = True
y = False
print(x and y)  #只有x和y同时为True时，结果为True
print(x or y)   #只要x和y其中一个为True时，结果为True
print(not x)    #取反，即x为True时，结果为False
print(x+y)    # 当两个布尔型进行算数运算时就会转换成int类型
1
2
3
4
5
6

3.3、字符串类型（String）

String类型是我们所熟知的类型，定义字符串值的时候可以用单引号，也可以用双引号。 这里只做初步认识，后面会讲字符串的具体用法

a = 'hello'
b = "world"
print(a,b)
 
输出结果为：
hello world
1
2
3
4
5
6

3.4、列表

3.4.1、声明列表

变量名 = [元素1,元素2,元素3,......,元素n]
列表中的数据称为列表的元素，元素之间用逗号分隔
同一个列表中可以有多个数据类型
列表中的元素是可以重复的，且是有序的
list1 = [1,2,3,4] 其中1,2,3,4 就是列表的元素
list2 = [1,2,3,'hello',12] 同一个列表中可以有多个数据类型
list3 = [1,2,3,4,1,2,3] 列表中的元素是可以重复的

3.4.2、 列表的索引

列表每一个元素都对应一个整数型的索引值，可以通过索引值来得到相应的元素值。
列表支持元素的正向索引和反向索引。正向索引即索引值为正，从0开始；反向索引即索引值为负，从-1开始。若是反向索引，则-1为末尾元素对应的索引编号。

list1 = [1,2,3,4,'hello']
print("列表list1的第一个值：",list1[0])
print("列表list1的最后一个值：",list1[-1])
1
2
3

3.4.3、 列表的切片

列表切片是指截取列表中的分元素，将截取的元素从新生成一个子列表
新列表 = 旧列表[起始值:终止值] （需要注意的是这里的切片位置是左闭右开的，也也就是说生成的新列表包含起索引对应的元素，但不包含终止索引对应的元素）

list1 = [1,2,3,4,5,6,7,8,9]
list2 = list1[2:6]
list3 = list1[-6:-3]
1
2
3

3.4.4、列表加法和乘法

加法操作使用加号（+）完成，表示把加号两端的列表变量连接形成一个新列表
乘法操作使用星号（*）完成，表示对当前列表对象进行复制并连接，并形成一个新列表

list1 = [1,2,3]
list2 = [4,5,6]
list3 = list1+list2
#不允许list1*list2
list4 = list1*3
print("list3=",list3)
print("list4=",list4)
 
输出结果如下：
list3= [1, 2, 3, 4, 5, 6]
list4= [1, 2, 3, 1, 2, 3, 1, 2, 3]
1
2
3
4
5
6
7
8
9
10
11

3.4.5、列表的修改

通过列表的索引进行修改
通过列表的切片进行修改

list1 = [1,2,0,4,5,6,7]
# 将索引值为2的元素的值修改为3
list1[2] = 3
print(list1)
list1[2:6]=[0,0,0,0]
print(list1)
 
# 输出结果为：
[1, 2, 3, 4, 5, 6, 7]
[1, 2, 0, 0, 0, 0, 7]
1
2
3
4
5
6
7
8
9
10

3.4.6、列表的删除

list删除有四种方法：del、pop、remove、clear
del ：关键字，强制删除,可以只删除列表中某个索引对应的值，也可以直接将整个列表删除
pop：如果不指定删除位置，则默认删除最后一个
remove：删除指定的值（只删除第一次匹配到相等的元素），如果没有匹配到就会报错
clear：清空列表，只是把列表中元素删除，但是列表还在

list1 = [1,2,1,4,5,6,7]
# 删除列表索引为1的值
del list1[1]
print("list1=",list1)

list2= [1,2,1,4,5,6,7]
# 默认删除列表中的最后一个值
list2.pop()
print("list2=",list2)
# 删除列表索引为1的值
list2.pop(1)
print("list2=",list2)
list3 = [1,2,1,4,5,6,7]
# 删除列表中值为1的元素，如果列表中有多个，则默认删除第一个
list3.remove(1)
print("list3=",list3) 
list4 = [1,2,1,4,5,6,7]
# 清空列表
list4.clear()
print("list4=",list4) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3.4.7、列表追加、插入和扩展

append：在当前列表对象尾部追加元素
insert：在当前列表的指定索引位置插入元素
extend：对当前列表元素进行批量增加

list1 = [1,2,3,4,5,6,7]
list1.append(8)
list1.append([9,10])
print("list1 =",list1)

list2 = [1,2,4,5,6,7]
#在列表索引值为2的位置，增加元素3
list2.insert(2,3)
print("list2 =",list2)

list3 = [1,2,3]
#对当前列表元素后面进行批量增加
list3.extend([4,5,6])
print("list3 =",list3)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3.4.8、列表元素查找

List运用index函数查找相应的元素，返回元素的索引，obj为元素值，start和end为 开始和结束索引（均可无）,如果元素不存在则报错
格式： list.index(obj,start,end) 如果找不到的话就会报错

list1 = [1,2,3,4,5,6]
print(list1.index(4,1,5))   # 查找到了索引位置为3
print(list1.index(5))        # 查找到了索引位置为4
1
2
3

3.4.9、列表相关的相关内置函数

3.4.10、多维列表

多维列表指的是列表的元素也是列表， 类似于多维数组

list1 = [1,2]
list2 = [1,2,3]
list3= [list1,list2]
print(list3) #[[1, 2], [1, 2, 3]]
1
2
3
4

3.5、元组

3.5.1、元组声明

Tuple元组的创建 变量名 = (元素1,元素2,…,元素n)
元组也是有序的。
元组从形式和列表相识，标志是小括号,当元组中只有一个元素时，需要在元素后面加逗号，元组的访问也是通过索引来访问的，并且支持切片操作。

tup1 = (1,2,3,4,'hello')
print(tup1)
#(1, 2, 3, 4, 'hello')
1
2
3

3.5.2、元组修改

元组是不可变数据类型，所以不能被修改，但可以重新赋值和用“+”进行连接产生新的元组

# 元组可以包涵多种数据类型
tup1 = (1,2,3,4,'hello')
# 当元组只有一个元素时，需要在元素后面加一个逗号
tup2 = ("world",)
# 给元组进行+ 运算，从新生成一个新的元组
tup3 = tup1 + tup2
print(tup3)
1
2
3
4
5
6
7

3.5.3、元组删除

元素值不允许删除的，但可使用del语句删除整个元组 需要注意的是，删除后的元组对象不可再次引用。

tup1 = (1,2,3,4,'hello')
del tup1
print(tup1)

#再次使用删除后的元组，会报下面的错误
Traceback (most recent call last):
  File C:\Users\zhanggang\Desktop\python\basic\test\Test2.py, line 3, in <module>
    print(tup1)
NameError: name 'tup1' is not defined
1
2
3
4
5
6
7
8
9

3.5.4、与元组相关的内置函数

3.5.5、元组与列表之间的转换

list1 =[1,2,3,45]
tuple1 = (91,2,3,4)
#元组转列表
list2 = list(tuple1)
#列表转元组
tuple2 = tuple(list1)
print(list2)     #[91, 2, 3, 4]
print(tuple2)     #(1, 2, 3, 45)
1
2
3
4
5
6
7
8

3.5.6、 元组的优势

可以使函数返回多个值,程序运行性能提升
一般来说，创建元组类型tuple的变量比列表类型list要快，而且占用更小的存储空间
使用元组是线程安全的
元组类型变量的元素不可更改性，可保证多线程读写时的安全问题

3.6、字典

3.6.1、 声明字典

变量名={key1:value1, key2:value2}，和json格式是一样的。
字典是无序的
字典的元素(value)是可变的，可以是任意数据类型，但键(key)值必须是不可变类型 在同一个字典变量中，键(key) 值必须是唯一的。

stu = {"name":"zhangsan","age":18,"sex":"男"}
print(stu)
1
2

3.6.2、 字典查找，修改，删除，增加

字典只能通过键值（key）来获取元素。两种获取的写法，字典名[key]和字典名.get("key")

stu = {"name":"zhangsan","age":18,"sex":"男"}
print(stu["name"],stu["age"])
print(stu.get("name"),stu.get("age"))
1
2
3

字典通过对key值的引用对value值进行修改

stu = {"name":"zhangsan","age":18,"sex":"男"}
stu["age"] ="20"
print(stu)
1
2
3

字典通过del关键字进行删除

stu = {"name":"zhangsan","age":18,"sex":"男"}
del stu["age"]
print(stu)
1
2
3

字典新增元素，格式：字典名[key] = value

stu = {"name":"zhangsan","age":18,"sex":"男"}
stu["county"] = "China"
print(stu)
1
2
3

3.6.3、 与字典相关的内置函数

3.7、集合

3.7.1、 声明集合

集合与列表非常相似，，只是列表用的是[],而集合用的是{}，他们都是可以修改的，对元素的类型没有限制。
声明格式：变量名 = {元素1,元素2}。
注意：集合元素之间没有确定的顺序且不会出现重复的元素，也就是无序性和不重复性。

set1 = {1,2,3,5,"123",1,2,3}
print(set1)
#{1, 2, 3, 5, '123'}

#元素和集合只有属于或不属于的关系。
set1 = {1,2,3,5,"123",1,2,3}
print(set1)
print(1 in set1)  #True
print( 1 not in set1)  #False
1
2
3
4
5
6
7
8
9

3.7.2、集合增加元素

add（）：添加一个元素。
update（）：同时添加多个元素。

set1 = {1,2,3,5,"123",1,2,3}
#添加一个元素
set1.add(23)
print("ste1=",set1)
set2 = {1,2,3,4}
#同时添加多个元素
set2.update({5,6,7,8})
print("ste2=",set2)
1
2
3
4
5
6
7
8

3.7.3、集合删除元素

discard() 和 remove() 方法删除集合中特定的元素。
若删除的对象不存在，remove（）方法会引起错误， discard（）方法不会。

set1 = {1,2,3,5,"123"}
set1.remove(1)
print(set1)
1
2
3

3.7.4、集合的数值运算

3.7.5、不可变集合frozenset

set 集合是可变序列，程序可以改变序列中的元素。
frozenset 集合是不可变序列，程序不能改变序列中的元素，若对其进行修改，添加，则会报错。

set1 ={1,2,3,4}
# set2是一个不可变集合，若对其进行修改，添加，则会报错
set2 = frozenset(set1)
1
2
3