Python基础学习

Posted 2020-11-26 后山人

这些都是比较简单的

python语言简介

1、python编程语言

    编程语言，可以理解为人类通过计算机指令与计算机沟通交流的语言，python是众多计算机编程语言中的一种。

2、Python的特点

    Python支持面向对象的编程思想，有着极其简单的语法，可以移植到Linux、Windows等众多系统平台， 具有可扩展性(部分程序可以使用其他语言编写，如c/c++。)、可嵌入型(可以把Python嵌入到c/c++程序中)以及非常丰富的专业库，是免费、开源的解释性的高层计算机语言。

编程入门

1、代码注释

    可以起到一个备注的作用，团队合作的时候，个人编写的代码经常会被多人调用，为了让别人能更容易理解代码的通途，使用注释是非常有效的。

    ①：单行注释以 # 开头

# 这是一个注释
print(‘Hello, World!‘)

　②：多行注释用三个单引号 ‘‘‘ 或者三个双引号 """ 将注释括起来

‘‘‘
这是多行注释，用三个单引号
这是多行注释，用三个单引号
这是多行注释，用三个单引号
‘‘‘
print(‘Hello, World!‘)
"""
这是多行注释，用三个双引号
这是多行注释，用三个双引号
这是多行注释，用三个双引号
"""
print(‘Hello, World!‘)

打印输出

print(‘hello‘)
print(‘python‘)

运行结果：

hello
python

注意：print()在输出完，内容后会自动换行，如果我们不需要输出后换行，可以通过end参数，指定输出后内容的结束形式

print(‘hello‘,end=‘‘)
print(‘python‘,end=‘‘)

运行结果：

hellopython

连续输出多个内容，将要输出的内容之间用,分开 

 print("5","中国",True)

运行结果：

 中国 True

转义字符的使用

 ①、输出语句含有(‘、""、等)特殊字符时需要使用 转义

print(‘\‘) # print(‘‘) 程序会报错误

运行结果：

代表换行

print(‘我爱你
中国‘)

运行结果：

我爱你
中国

代表八个空格

print(‘我爱你	中国‘)

 运行结果：

我爱你  中国

　变量

    是计算机语言中能储存计算结果或能表示值抽象概念（会在计算机内存中开辟一块空间）。

    定义格式：变量名 = 初始化值

1、变量：可以被改变的量(存储数据的空间,类似于容器)

name = ‘小红‘
print(name)
name = ‘小李‘ #小李 会覆盖掉 小红
print(name)

运行结果：

小红
小李

多目标赋值(不建议使用)

num1,num2 = 3,4  #第一种方式
print(num1)
print(num2)
num3 = num4 =5  #第二种方式
print(num3)
print(num4)

　运行结果

3
4
5
5

　命名规则：

    ①、只能是字母、数字、下划线组成，不能以数字开头

    ②、字母大小写敏感代表不同含义，不能使用python保留的关键字

    命名规范：

    ①、见名知义，尽量不要用小写字母i和大写字母的O(避免与数字1、0混淆)

    注意： 变量，必须设置初始化值，以达到节省内存空间的原则(从计算机内存条开辟出来的)

　标准数据类型

    对所有数据分类的划分，解决数据更方便的管理、表述及使用。

    Python3 中有六个标准的数据类型

    1、Number(数字)

    2、String(字符串)

    3、List(列表)

    4、Tuple(元组)

    5、Set(集合)

    6、Dictionary(字典)

    注意：

        可以使用 type(对象) 函数来查看数据类型

        不可变的对象：数字 、元组 、字符串

Number(数字) 类型

    Python3的数字类型支持 int、float、bool、complex（复数）

1、int -> 整数

    表示为长整型，包含正整数和负整数,在这里整数被允许具有无穷的精度 （只要内存空间允许，它可以增长成任意位数的数字）

age = 18 #年龄
score = 90 #成绩
print(‘年龄是：‘,age)
print(‘成绩是‘,score)
print(type(score))

运行结果：

年龄是：18
成绩是 90
<class ‘int‘>

float -> 小数

    表示为小数，带一个小数点，也可以加上一个科学计数标志e或者E

avg_score = 90.5  #平均成绩
price = 99.8 #单价
num_value = 3.14e-10 #科学计数
print(‘平均成绩为：‘,avg_score)
print(‘单价为：‘,price)
print(‘科学计数的值：‘,num_value)
print(type(price))

 运行结果：

平均成绩为：90.5
单价为：99.8
科学计数的值：3.14e-10
<class ‘float‘>

　bool -> 布尔(判断)

    表示为布尔类型，值为True 和False，也可以用数字表示：0 表示 False，1 表示 True ，同时也可以进行运算

isTrue = True
isHeight = False
isTrue2 = 1
isHeight2 = 0
isValue = isTrue+isTrue2
print(‘isTrue的值是：‘,isTrue)
print(‘isHeight的值是：‘,isHeight)
print(‘isTrue2的值是：‘,isTrue2)
print(‘isHeight2的值是：‘,isHeight2)
print(‘isValue的值是：‘,isValue)
print(type(isTrue))

　运行结果：

isTrue的值是：True
isHeight的值是：False
isTrue2的值是：1
isHeight2的值是：0
isValue的值是：2
<class ‘bool‘>

complex -> 复数

    复数常量写成实部+虚部的写法，虚部是以j或J结尾的

compileValue = 3+4j
print(‘compileValue的值为：‘,compileValue)
print(type(compileValue))

　运行结果：　　

compileValue的值为：(3+4j)
<class ‘complex‘>

　python序列

    就是有序存放的一组数据，这组数据由一个个独立的元素组成

1、python中六种序列：

    列表、元组、字符串、Unicode字符串、buffer对象、xrange对象

2、python序列特征：

    ①、元素有序存放，并每个元素都有一个索引，从0开始......

    ②、序列都能够进行索引操作、切片操作、加法运算、乘法运算和检查元素

            根据索引修改或查找元素的值，根据元素的值查找元素的索引

            切片操作能够获取序列中任意一段的数据

    ③、能够自动计算出序列类型的长度len()，最大值max()、最小值min()

String(字符串) 类型

1、简单使用

    字符：所有的单个数字、文字、字母以及特殊的符号都叫字符

    字符串：多个字符连接的串

    ①、单行字符串用‘...’ ， “...”来定义

name = ‘小红‘
name2 = "小花"
print("name的值为：",name)
print("name2的值为：",name2)

 运行结果：　

name的值为：小红
name2的值为： 小花

多行字符串用‘‘‘...‘‘‘ ， """..."""来定义

info = ‘‘‘我是一个帅哥
！‘‘‘
info2 = """我是一个帅哥
很帅！"""
print("info的值为：",info)
print("info2的值为：",info2)

运行结果：

info的值为：

我是一个帅哥

info2的值为：

我是一个帅哥
很帅！

字符串格式化

    问题：求100+300的和，在屏幕上输出：100+300=400

    ①、format实现

num01 = 100
num02 = 300
print(num01+num02)
print(‘100+300={}‘.format(num01+num02)) #不写，默认从0开始
print(‘{}+{}={}‘.format(num01,num02,(num01+num02))) #不写占位符的下标，默认从0开始
# 后面值的顺序要与前面占位符下标的顺序保持一致
print(‘{0}+{1}={2}‘.format(num02,num01,(num01+num02)))

运行结果:　

400
100+300=400
100+300=400
100+300=400

　　%实现

num01 = 100
num02 = 300
print(num01+num02)
print(‘100+300=%i‘%(num01+num02))
# 后面值的顺序要与前面占位符的顺序保持一致
print(‘%i+%i=%i‘%(num01,num02,(num01+num02)))

运行结果：

400
100+300=400
100+300=400　

注意：推荐使用format，可以复用："5+3={0},5-3={1}{0}".format(5+3,5-3)

3、字符串操作

    字符串中的字符都是有索引的，从0开始。

    字符串是序列，是用索引来表示元素的位置的，因此凡是对元素的操作，都离不开索引。

    ①、len(字符串名)：计算字符串的长度

s = ‘divpspan‘
print(‘字符串的长度为：{}‘.format(len(s)))

运行结果：

字符串的长度为：8

根据序列索引找字符

    注意：正向索引从左边开始计算，从0开始，反向索引从右边开始计算，从最后一个(-1)开始

str = ‘divpspan‘
print(‘索引为4的字符时：{}‘.format(str[4])) #正向索引（左[0开始] -> 右）
print(‘索引为-1的字符时：{}‘.format(str[-1]))  #反向索引（右[-1开始] -> 左）

　运行结果：

索引为4的字符时：s
索引为-1的字符时：n

合并

    字符串作为一个序列，字符串支持用+,+=进行拼接，或者用*进行重复

    +,+=操作时，只要两边都是字符串叫做字符串连接符；反之为操作运算符；数值与字符串不能互相运算和连接

#只要两边都是字符串叫做字符串连接符；反之为操作运算符
#print("6"+9)  #报错：数值与字符串不能互相运算
print(6+9)  #运算符
print(‘6‘+‘9‘)  #字符串连接符
print(‘8‘*3)  #将前面字符串复制3倍

    运行结果：

15
69
888

   ④、title() 将每个单词的首字母都改为大写

info_val = ‘i love you‘
print(info_val.title())

    运行结果：

I Love You

    ⑤、upper()将字符串改为全部大写或lower()改为全部小写

info_val = ‘i lOvE yOU‘
print(info_val.upper()) #改为全部大写
print(info_val.lower()) #改为全部小写

    运行结果：

I LOVE YOU
i love you

    ⑥、删除空格

    剔除字符串末尾的空白：rstrip() 

    剔除字符串开头的空白：lstrip() 

    剔除字符串两端的空白：strip()

strValue = ‘ i love you ‘
print(strValue.rstrip()) #删除字符串末尾空格
print(strValue.lstrip()) #删除字符串开头空格
print(strValue.strip())  #删除字符串两端的空格

    运行结果：

i love you
i love you 
i love you

    ⑦、raw字符串

    raw字符串表示原始字符串：你看到这个字符串是什么就显示什么，所有字符都不进行转义

    写法：在字符串前面加r

    作用：如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦，可以通过在字符串前面加r，抑制转义，里面的字符就不会转义了

abc = ‘\‘  #只打印一个(一个作为转义)
defg = r‘\‘  #通过使用r 字符串中的字符将都不做转义
print(abc)
print(defg)
url = ‘d:	bcdefgfh	‘  #	 转义操作
url2 = r‘d:	bcdefgfh	‘  #通过使用r 字符串中的字符将都不做转义
print(url)
print(url2)

    运行结果：

d:  bcdefgfh  
d:	bcdefgfh	

 ⑧、字符串分片

    分片：从一个字符串中取出一部分的方法。

    格式：X[I:J] 含义：取出在X中从偏移量为I，直到但不包含偏移量为J的内容。 

    注意：分片的左边界默认为0，右边界默认为分片序列的长度

s1 = ‘adfj,k=国l78wm‘
print(s1[1:6]) #得到切片：dfj,k
print(s1[2:-3]) #得到切片：fj,k=国l7
print(s1[:-3]) #得到切片：adfj,k=国l7
#左边不写，默认值为从0开始   右边不写，默认值是序列的长度len(s1)
print(s1[:]) #得到切片：全部内容
print(s1[:len(s1)]) #得到切片：全部内容
#序列从左往右...(从最后一个切，是没有值的)
print(s1[-1:1])#没有输出
#结果为去除掉最后一个字符
print(s1[:-1])#得到切片：adfj,k=国l78w

运行结果：

dfj,k
fj,k=国l7
adfj,k=国l7
adfj,k=国l78wm
adfj,k=国l78wm

adfj,k=国l78w

⑨、类型转换

  隐式转换(自动类型转换)：小范围类型数据向大范围类型数据转换，自动完成。

num1 = 8.2+5  #3自动转为浮点型，输出：13.2

    运行结果：

13.2

       显示转换(强制类型转换)：手动指定数据的类型

# num = ‘8‘+3  #报错  需要转换
num2 = int(‘2‘)+3  #将str类型的数据”2”转为int类型数据2，输出：5
num3 = ‘2‘+str(3)  #将int类型的数据3转为str类型数据”3”，输出：23
num4 = int(3.2) #将float类型的数据转为int类型数据，输出：3
print(num1)
print(num2)
print(num3)
print(num4)

运行结果：

5
23
3

    ⑩、字符串的特点

    特点：不可变性——在创建后不能就地改变。

    注意：不能通过任何操作对原始的字符串进行改变，每个字符串都被定义为生成新的字符串作为其结果。在核心类型中，数字，字符串和元组是不可变的；列表和字典是可变的。

List(列表) 类型

    列表是序列，能存放多个元素的容器

    是一个任意类型的对象(元素)的位置相关的有序集合，它没有固定大小(长度可变)。

1、列表常用操作

student = [‘张三‘,‘李四‘,‘王五‘]
print(student[1])  #根据索引找元素
print(len(student))  #列表的长度
print(student[1:3])  #分片的应用
num_list2 = [] #定义空列表

 运行结果：

李四
3
[‘李四‘, ‘王五‘]

2、追加列表元素

student = [‘张三‘,‘李四‘,‘王五‘]
#末尾追加一个元素
student.append(‘赵六‘)
print(student)
#末尾追加一个列表
s2=[‘小明‘,‘小红‘]
student.extend(s2)
print(student)
#追加任意位置，原位置占用，后面元素后移
student.insert(1,‘小丽‘)
print(student)

  运行结果：

[‘张三‘, ‘李四‘, ‘王五‘, ‘赵六‘]
[‘张三‘, ‘李四‘, ‘王五‘, ‘赵六‘, ‘小明‘, ‘小红‘]
[‘张三‘, ‘小丽‘, ‘李四‘, ‘王五‘, ‘赵六‘, ‘小明‘, ‘小红‘]

3、修改列表元素

    要修改列表元素，可指定列表名和要修改的元素的索引，再指定该元素的新值

student = [‘张三‘,‘李四‘,‘王五‘]
student[1]=‘小王‘;
print(student)

    运行结果：

[‘张三‘, ‘小王‘, ‘王五‘]

4、删除列表元素

student = [‘张三‘, ‘小丽‘, ‘李四‘, ‘王五‘, ‘赵六‘, ‘小明‘, ‘小红‘]
#根据索引删除元素
del student[1]
print(student)
#pop返回被删除的元素
#默认删除最后一个元素
student.pop()  
print(student)
student.pop(1) #删除索引为 1的元素
print(student)
#删除（根据元素的值），返回值为被删除的元素
#删除一个不存在的元素，会报错
student.remove(‘小明‘)
print(student)

    运行结果：

[‘张三‘, ‘李四‘, ‘王五‘, ‘赵六‘, ‘小明‘, ‘小红‘]
[‘张三‘, ‘李四‘, ‘王五‘, ‘赵六‘, ‘小明‘]
[‘张三‘, ‘王五‘, ‘赵六‘, ‘小明‘]
[‘张三‘, ‘王五‘, ‘赵六‘]

5、对列表元素排序

#sort() 对列表进行永久性排序，将原列表改变，升序
num_list = [1,5,7,4,9,33,2]
num_list.sort()
print(num_list)  #[1, 2, 4, 5, 7, 9, 33]
#降序
num_list.sort(reverse = True)
print(num_list)  #[33, 9, 7, 5, 4, 2, 1]

#对原列表，做临时排序不会更改原列表
num_list2 = sorted(num_list)
print(num_list2) #[1, 2, 4, 5, 7, 9, 33] 数据临时改变
print(num_list) #[33, 9, 7, 5, 4, 2, 1] 原来列表数据没有改变
#反转列表元素：按照中心轴转一圈
num_list.reverse()
print(num_list) #[1, 2, 4, 5, 7, 9, 33]

　　运行结果：

[1, 2, 4, 5, 7, 9, 33]
[33, 9, 7, 5, 4, 2, 1]
[1, 2, 4, 5, 7, 9, 33]
[33, 9, 7, 5, 4, 2, 1]
[1, 2, 4, 5, 7, 9, 33]

6、列表的特殊操作

num_list2 = [] #定义空列表
num_list3 = [6,0,5]
num_list2.append(num_list3)
print(num_list2)   # [[6, 0, 5]]
num_list2.append(num_list3)
print(num_list2)   #[[6, 0, 5], [6, 0, 5]]
print(num_list2[0][1])   # 0
#列表不能自己加自己（会循环加下去...）
num_list3.append(num_list3)
print(num_list3)   #[6, 0, 5, [...]]

  运行结果：

[[6, 0, 5]]
[[6, 0, 5], [6, 0, 5]]
0
[6, 0, 5, [...]]

---

 Tuple(元组) 类型

    元组与列表类似，不同之处在于元组的元素不能修改(元素不能改变顺序、不能增伤改元素、不能给元组的元素赋值)

    相比于列表，元组是更简单的数据结构，如果需要存储的一组值在程序的整个生命周期内都不变，可使用元组。

    元组可以存放任意类型

    可以定义一个空的元组，但意义不大（因为它不能增删改）

number = (1,5,8,2,10)
print(number[1])  #使用索引
print(number[:3]) #使用切片

运行结果：

5
(1, 5, 8)

    虽然不能修改元组的元素，但可以给存储元组的变量赋值。因此，如果要修改数据，可重新定义整个元组：

numbers = (200, 50)
print(numbers)
numbers = (1,2,3,4)
print(numbers)

    运行结果：

(200, 50)
(1, 2, 3, 4)

---

Dictionary (字典)

    是一系列键值对，每个键都与一个值相关联，你可以使用键来访问与之相关联的值

    与键相关联的值，可以是数字、字符串、列表、字典（事实上，可将任何python对象用作字典中的值）

    字典的键是无序，键不能重复，重复后，后面的值会覆盖前面的值

zidian = {‘身高‘:175,‘体重‘:130,‘肤色‘:‘黄色‘}
print(zidian)  #查看字典结构
print(type(zidian))  #查看类型
print(zidian[‘体重‘])  #查看字典键‘体重‘的值
zidian[‘性别‘] = ‘男‘ #增加一个键值对元素
print(zidian)
zidian[‘身高‘] = 180; #增加一个存在的键，等同于修改
print(zidian)
#根据键删除字典元素
del zidian[‘肤色‘]
print(zidian)
zidian.pop(‘身高‘)
print(zidian)
#创建一个空的字典
zidian2 = {}
print(zidian2)

运行结果：

{‘身高‘: 175, ‘体重‘: 130, ‘肤色‘: ‘黄色‘}
<class ‘dict‘>
130
{‘身高‘: 175, ‘体重‘: 130, ‘肤色‘: ‘黄色‘, ‘性别‘: ‘男‘}
{‘身高‘: 180, ‘体重‘: 130, ‘肤色‘: ‘黄色‘, ‘性别‘: ‘男‘}
{‘身高‘: 180, ‘体重‘: 130, ‘性别‘: ‘男‘}
{‘体重‘: 130, ‘性别‘: ‘男‘}
{}　

---

 Set(集合) 类型

    是一个无序(没有索引，没有顺序)不重复元素的序列,类似于字典，是一组不存储value的key的集合

    set集合不支持索引

    作用如下：

         ①、去重：把一个列表变成集合，就自动去重啦

         ②、测试两组数据之前的交集、差集、并集等关系

1、简单操作

ss1 = {1,5,3,4,2,1,‘c‘,‘b‘,‘a‘,‘d‘}
#查看类型
print(type(ss1))
#查看集合结构 -> 元素自动去重
#打印结果无序，结果根据计算机底层编码有关
print(ss1)
#成员运算符: in ，如果在指定的序列中找到值，返回True,否则返回False
print(5 in ss1)  #判断集合中是否存在 5

   运行结果：

<class ‘set‘>
{1, 2, 3, 4, 5, ‘c‘, ‘b‘, ‘d‘, ‘a‘}
True

2、列表List与集合转换Set

#将列表list转换成集合set -> 元素自动去重
list_num = [1,2,3,4,5,1,6]
ss2 = set(list_num)
#查看对象类型
print(type(list_num))
print(type(ss2))
print(ss2)
#将set转换成list
list2 = list(ss1);
print(type(list2))

  运行结果：

<class ‘list‘>
<class ‘set‘>
{1, 2, 3, 4, 5, 6}
<class ‘list‘>

3、集合运算

set01 = set(‘abcda‘)
set02 = set(‘afg‘)
print(set01) #{‘a‘, ‘b‘, ‘d‘, ‘c‘}
print(set02) #{‘g‘, ‘a‘, ‘f‘}
#差集 a中不包含b的东西
print(set01-set02)  #{‘c‘, ‘b‘, ‘d‘}
#并集 a与 b中所有不重复的元素
print(set01|set02) #{‘g‘, ‘c‘, ‘f‘, ‘a‘, ‘b‘, ‘d‘}
#交集 a与 b中共同有的元素
print(set01&set02) #{‘a‘}
#a 和 b中不同时存在的元素
print(set01^set02) #{‘g‘, ‘c‘, ‘b‘, ‘f‘, ‘d‘}

 运行结果：

{‘a‘, ‘b‘, ‘d‘, ‘c‘}
{‘g‘, ‘a‘, ‘f‘}
{‘c‘, ‘b‘, ‘d‘}
{‘g‘, ‘c‘, ‘f‘, ‘a‘, ‘b‘, ‘d‘}
{‘a‘}
{‘g‘, ‘c‘, ‘b‘, ‘f‘, ‘d‘}

常用集合操作

ss10 = set([1,2,3])
print(ss10)
ss10.add(5)  #填加一个元素
print(ss10)
ss10.update([8,9,0])  #填加多个元素
print(ss10)
ss10.remove(5) #删除一个元素
print(ss10)

    运行结果：

{1, 2, 3}
{1, 2, 3, 5}
{0, 1, 2, 3, 5, 8, 9}
{0, 1, 2, 3, 8, 9}

　　个人推荐入门学习较好的网站   https://www.liaoxuefeng.com/wiki/1016959663602400/1016959735620448

我的入门就是看廖大师的杰作学习的 希望小伙伴们努力加油!!!

QQ1696630419

---

---