python基础01

发表于 | 分类于

第一个python程序

​ 在python中程序的执行是自上而下的，从没有缩进的代码开始执行，只有处于调试状态下才可以设置断点

1
print("hello world")

image-20191202135842459

数值类型

​ 一切编程语言都是以数据为基石的，python中提供的基本数据类型

类型 英文 数据
整形 int 整数，无限
浮点型 float 小数
负数 complex 负数由实数部分和虚数部分构成

​ python中的证书类型，type可以被用于查看指定数值或变量的类型

1
print(type(10), 10)

image-20191202140246824

在python3中，所有的整数都是int类型，可以表示的范围是无限的

1
print(123456789 ** 10)

image-20191202140423872

也可以将十进制数转换成不同进制的数

1
print(hex(100), oct(100))

image-20191202140515719

也可以将字符串对应的进制转换成十进制

1
print(int('64',16))

image-20191202140627124

字符串类型

​ python中没有单字符类型，只有字符串类型，被包裹再’’或””之间。

​ python中的字符串类型：str

1
2
3
print("this is a \"string\"")
print('this is a "string"')
print('''this is a "string"''')

image-20191202140917047

单引号(双引号)中输出双引号(单引号)需要转义

三个单引号使用最多的是 多行注释

python中的变量

变量与标识符

​ 在python中定义变量，不需要写变量类型，但是需要初始化，会根据初始化的数据类型自动设置变量类型

​ 第一次存入一个值，变量就被初始化（或创建）此后，可以在表达式中使用它

​ 变量的名字也叫做标识符，python中标识符定义规则如下

  • 由字母，数组，下划线组成
  • 第一个字母必须是字母或者下划线
  • 对大小写敏感
  • 不能是关键字

关键字

python中的关键字

算数 引入 异常 控制 操作与状态 返回退出 定义
and import except while del return lambda
or as try if assert yield class
in from finally else True continue def
is raise elif Flase pass global
not with for None break nonlocal

python中的布尔类型全部为首字母大写

1
print(True, False)

python是一个弱类型的语言，意思指的是在程序的运行过程中，变量的类型可能是变化的，指明变量的类型没有意义

1
2
3
4
number = 100
print(type(number))
number = 1.1
print(type(number))

image-20191202141417967

每一个变量都有一个对应的引用计数，当一个变量的引用计数变为0的时候，变量会被销毁

1
2
3
4
5
6
7
import sys
s = "this is a string"
print(sys.getrefcount("this is a string"))
s1 = s
print(sys.getrefcount("this is a string"))
del s1
print(sys.getrefcount("this is a string"))

image-20191202141602271

python中的输入与输出

​ python中的输入函数为input，在输入的时候就可以输入提示信息，例如：

1
a = input("请输入一个数字")

input函数返回的是一个str类型的数据

可以通过eval将输入的内容自动转换成与输入对应的类型

1
2
3
4
a = input("请输入一个数字")
print(type(a), a)
a = eval(input("请输入一个数字"))
print(type(a), a)

image-20191202142647290

python3中输出主要使用函数print，print函数可以接收不确定个数的参数，并且能够将其格式化输出

方式一：使用%进行格式化输出

1
print("%d * %d = %d" %(10,10,10 * 10))

image-20191202142853134

方式二：使用format进行格式化输出

1
print("{} * {} = {}".format(10,10,10 * 10))

image-20191202143047176

python基础语法

python中的运算符 ** (求n方)

1
print(2**3)

image-20191202143202441

python中的运算符之 / (保留小数)和 // (截断除法)

1
2
print(2 / 3)
print(2 // 3)

image-20191202143312393

python中的运算符之 == (值)和 is (地址)

在python2中 <> 的意思就是不等于

1
2
3
4
5
6
l1 = [1, 2, 3]
l2 = l1  #浅拷贝
print(l1 == l2, l1 is l2)
l3 = l1.copy()  #深拷贝
print(l1 == l3, l1 is l3)
print(hex(id(l1)), hex(id(l2)), hex(id(l3))) #输出地址

image-20191202143636373

python中的运算符之 in (某一个元素是不是指定序列的成员)

1
2
print('a' in 'abc')
print('d' not in 'abc')

image-20191202143819002

选择结构

python中只有 if else 没有switch case 

1
2
3
4
5
6
7
8
9
number = eval(input("请输入一个数："))
#if后面紧跟一个表达式，不需要添加括号，每一条if或者else后面都需要添加冒号[:]
#紧跟着的下一行必须要进行缩进，同一级别的缩进会被作为一个语句块
if number % 2 ==1:
    print("这是一个奇数")
    print("这是if的语句块")
else:
    print("这是一个偶数")
    print("这是else的语句块")

image-20191202144255377

一些常见表达式的结果值：对于数值类型，非空就是True，

对于序列类型（字符串、列表），没保存东西就是Flase

列表

python中的基本类型值列表

列表的基本操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
l = [1, "2", 3.3, False]
#只要以[]中括号包含，就会被认为是一个列表
print(type([]))
#列表中可以保存不同类型的元素
print([1, "123", 1.1, False, None])
#列表的设置和访问和数组是相同的
print(l[3])
#列表中可以在此保存列表
l[0] = [1, 2, 3, 4]
print(l, l[0][3])
#python中列表的方法(成员函数)和函数(全局函数)
l = [1, 2, 3, 4, 5, 6, 7]
#计算长度，可以用于所有序列，包括str
#可以使用count方法
print(len(l))
#拼接，可以使用extend方法
print([1, 2, 3] + [4, 5, 6])
#重复
print([1, 2, 3] * 3)
#比较
print([1, 2, 3] is [1, 2, 3])
print([1, 2, 3] == [1, 2, 3])
#最大值
print(max(1, 3, 5, 7, 9))
#将字符串转换成列表
print(list("123456"))
#添加数据到列表的结尾
l.append(123456789)
print(l)
#查找，传入值返回下标
print(l.index(123456789))
#删除指定位置的元素，并进行返回
i = l.pop(7)
print(l, i)
#删除找到的指定元素，没有返回值
i = l.remove(7)
print(l, i)
#反转列表
l.reverse()
print(l)
#排序有两种方法
#使用成员函数sort
#使用全局函数sorted
print(sorted(l,reverse=False))
#列表的切片操作(字符串也可以切片)
l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#l[起始位置:结束位置(不包括):步进]
print(l[0:10:3])
#第一个值不写默认是起始位置
#第二个值默认是结束位置
#第三个值默认是1
print(l[::])
#逆向输出列表的所有元素
print(l[::-1])
#使用range快速生出有一定规律的列表
l = list(range(0, 100, 10))
#range 可以只接收一个参数，作为结束位置
print(l)

元祖

元祖是不可变的序列，它使用 圆括号逗号 来表示

1
2
t = 1,
print(type(t), t)

image-20191202150137709

元祖的解包：使用 a,b = b,a的写法可以交换两个数，元祖有一个特性，当将一个元祖作为等号右边的时候，如果等号的左边变量的个数和元祖内元素的个数相同的时候，就会将元祖的每一个元素按照顺序赋值给前面的变量

1
2
a, b, c, d, e = (1, 2, 3, 4, 5)
print(a, b, c, d, e)

image-20191202150429548

首先使用 , 将等号右边的b和a组成了一个临时的元祖(20,10)，对这个元祖进行解包，赋值给a b

1
2
3
4
a = 10
b = 20
a, b = b, a
print(a, b)

image-20191202150554833

元祖的不变指的是保存的内容不变

1
t = (1, [2, 3, 4], 5)

实际上元祖中保存的是(1的地址，列表的地址，5的地址)

t[0] = 10 相要修改元祖内第一个元素的数据，不能成功

t[1] [0] =10 修改的实际上是元素二的列表保存的内容，没有修改本身

集合

基本类型之 集合{元素} ，元素之间没有特定关联，集合内的数据是保持唯一的

1
2
s = { 10, 10, 10, 20, 30, 40, 40 }
print(type(s), s)

image-20191202151013792

字典

字典是一种可变容器模型，且可存储任意类型对象

1
2
d = { 'a': 1, 'b': 2 }
print(type(d), d)

image-20191202151130300

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
d = { 'a': 1, 'b': 2 }
print(type(d), d)
#使用键名访问到值
print(d['a'])
#堆同意元素的多次赋值会进行覆盖
d['a'] = 100
#字典的值可以是任何类型，但是键只能是不可变类型
d = { 1:1, 2.2:2, "3":3, (4,):4 }
print(d)
#可变类型：set list dict
#不可变类型：int float bool string tuple
#相关联的函数：键、值、键值对
print(d.keys())
print(d.values())
print(d.items())

python中的while循环使用方式和c\c++相同

python中的for循环

1
2
3
for i in range(100):
    print(i, end="-")
print()

循环遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
l = list("123456789")
#for循环遍历列表方式一：
for i in l:
    print(i, end=" ")
print()
#for循环遍历列表方式二：
for i in range(len(l)):
    print(l[i], end=" ")
print()
#for循环遍历列表方式三：
for index,item in enumerate(l):
    print(index, item, end="   ")
print()

image-20191202152042378

for中可以搭配break和continue

for搭配break和else可以生成新的语法

1
2
3
4
5
6
7
8
9
10
11
12
#迭代10到20之间的数字
for num in range(10, 20):
    for i in range(2, num):
        #判断能否被2~自己之间的数整除
        if num % i == 0:
            j = num / i
            print("%d 等于 %d * %d"%(num, i, j))
            #跳出当前循环
            break
    else:
        print(num,"是一个质数")
#如果循环被break打断了就不会执行else

image-20191202152537522

使用列表生成式：生出有一定规则的列表

1
2
l = [i for i in range(100) if i % 8 == 0]
print(l)

image-20191202152741070

1
2
l = [i for i in range(100) for j in range(100) if j % 8 == 0]
print(l)

遍历字典的方式，三种依赖三个函数

1
2
3
4
5
6
7
8
9
10
11
12
13
d = { 1:1, 2.2:2, "3":3, (4,):4 }
#直接遍历值
for value in d.values():
    print(value, end=" ")
print()
#通过键获取值
for key in d.keys():
    print(d[key], end=" ")
print()
#获取键值对
for key, value in d.items():
    print(key, value, end="   ")
print()

image-20191202153100557

函数

python中的函数使用def定义，后面紧跟着函数名和参数列表，参数没有指定类型，而且也不需要指定返回值的类型

1
2
3
def func():
    print("这是一个函数")
func()

image-20191202153336503

接收两个数，使用return返回较大的值

1
2
3
def maxinum(n1, n2):
    #如果n1>n2成立则返回n1否则返回n2
    return n1 if n1 > n2 else n2

一个没有返回值的函数

1
2
3
4
def noreturn(n1, n2):
    #空函数
    #return None
    pass

函数的默认参数，参数的设定必须从右向左

1
2
3
def defaultpram(n, m=10):
    print(n, m)
defaultpram(10)

使用函数时指定某一个参数的值

1
2
3
def test(a, b, c):
    print(a, b, c)
test(c=1,b=2,a=3)

给函数传入不确定个数的参数之元祖(*)

如果参数添加了*表示接收的数据会被组合成一个元祖进行保存，传入的数据是不能够被改变的

1
2
3
def my_print(*arg):
    print(type(arg), arg)
my_print(1, 2, 3, 4)

给函数传入不确定个数的参数之字典(**)

当参数指定为**的时候，表示传入的会被组织成一个字典，传入的必须是键值对，传入的内容能够被修改

1
2
3
def my_print(**arg):
    print(type(arg), arg)
my_print(one = 1, two = 2)

python中的作用于分为全局的和函数内的

1
2
3
4
5
6
7
8
def test():
    #当前num是局部的，再函数外不可访问
    #可以使用global关键字将局部的修饰为全局的
    global g_number
    g_number = 10
#全局的访问不到局部的
test()
print(globals(), g_number)
1
2
3
4
5
6
7
8
9
g_number = 100
def test():
    # 在函数内可以访问，但是不能直接修改全局的数据
    # 使全局变量能够在函数内进行修改
    g_number = 10
    # 用于输出所有的局部变量
    print(locals())
test()
print(g_number)