---

前言

本文旨在介绍Python编程的入门知识和基本概念，帮助初学者了解该语言的基本原理和应用场景。无论是对于计算机编程完全陌生的读者，还是已经具有其他编程语言经验的读者，都可以通过本文快速掌握Python编程的基础知识。

我们将简要介绍Python的背景和特点，解释为什么它成为目前最受欢迎的编程语言之一。然后，我们会逐步引导读者了解Python的基本语法、数据类型、条件语句和循环结构等基础知识。在此基础上，我们将介绍Python中常用的库和模块，以及如何利用它们开发实际应用程序。

---

一、python概述

Python是一门优雅而健壮的编程语言，他继承了传统编译语音的强大性和通用性，同时也借鉴了简单脚本的解释语言的易用性。

python的创始人苏姆，在1989年的圣诞节期间，因为无聊，决定开发一个新的脚本解释程
序，作为abc语言的一种继承，而之所以选中python作为该语言的命名，是因为他当时是派
森的狂热粉丝，派森是取自英国20实际首播的电视喜剧《monty python》,所以就用python来命名这一编程语言。

python特点：简单易学、高级语言、解释型语言、可移植性、面向对象、强大的功能、开源、可扩展性、丰富的库、规范代码

强大的功能：Python强大的功能可能才是大多数用户支持Python的最重要的理由，从字符串处理到复杂的3D图形编程，Python可以使用扩展模块简单地进行。

可扩展性：Python本身被设计为可扩充的。并非所有的特性和功能都集成到语言核心。Python提供了丰富的API和工具，以便程序员能够轻松地使用C语言、C++、Cython来编写扩充模块。Python编译器本身也可以被集成到其它需要脚本语言的程序内。因此，很多人还把Python作为一种“胶水语言”（glue language）使用，将其他语言编写的程序进行集成
和封装。比如机器学习就是一个很好的例子。

丰富的库：Python拥有丰富而强大的标准库，可以帮助处理正则表达式、文档生成、单元测试、线程、数据库、Web浏览器、CGl、FTP和电子邮件等各种任务，所有这些功能都可以使用，所以Python语言的功能非常强大。

规范代码：使用Python编写代码时强制缩进可以使代码具有非常好的可读性。

解释语言和编译语言有什么不同？
而我们所学的python又是这两种语言的哪一种呢？

一、编译型语言：编译型语言在执行之前要先经过编译过程，编译成为一个可执行的机器语言的文件，比如exe。因为翻译只做一遍，以后都不需要翻译，所以执行效率高。


编译型语言的典型代表：C语言，C++。
优缺点：执行效率高，缺点是跨平台能力弱，不便调试。

二、解释型
解释型语言：解释性语言编写的程序不进行预先编译，以文本方式存储程序代码。执行时才翻译执行。程序每执行一次就要翻译一遍。


代表语言：python，JavaScript。
优缺点：跨平台能力强，易于调，执行速度慢。。

python2.x与python3.x版本区别
python的3.0版本，常被称为python 3000，或简称Py3k。相对于python的早期版本，这是
一个较大的升级。为了不带入过多的累赘，python 3.0在设计的时候没有考虑向下相容。
许多针对早期 Python 版本设计的程式都无法在 Python 3.0 上正常执行。
为了照顾现有程式，Python 2.6 作为一个过渡版本，基本使用了 Python 2.x 的语法和库，同
时考虑了向 Python 3.0 的迁移，允许使用部分 Python 3.0 的语法与函数。
新的 Python 程式建议使用 Python 3.0 版本的语法。所以我们本次课程只讲Python3。

1、下载和安装

官方网站: http://python.org
目前可下载最新版本：

python代码编写
安装后，Linux下一般需要配置，但是Kali中已经设置好了，一般无需额外设置

1. 指定python解释器
   #!/usr/bin/python
   #!/usr/bin/env python
2. 字符编码:
   #encoding:utf-8
   #coding:utf-8
   ASCII只能识别英文
   UTF-8 是「编码规则」, 可以识别中文和英文

Windows下安装后，会有如下菜单选项

PyCharm 集成化管理工具
PyCharm是一种Python IDE，带有一整套可以帮助用户在使用Python语言开发时提高其效率的工具，比如调试、语法高亮、Project管理、代码跳转、智能提示、自动完成、单元测试、版本控制。
此外，该IDE提供了一些高级功能，以用于支持Django框架下的专业Web开发。
简而言之，PyCharm 之类的集成化管理工具比较适合大型项目的开发
下载地址: https://www.jetbrains.com/pycharm/download/

2、python基础

第一句Python语句

print("hello world")

2.1 变量

message = "hello world ,Python"
print(message)# 在程序中可以随时改变量的值
message = "hello world ,Python"
print(message)
message="hello world again,Python"
print(message)

概念
变量是程序在运行过程中可以变化的量。
变量是内存中的一块区域。对象赋值实际上是对象的引用。a=10


python变量的特点：
在程序中，可以随便修改变量的值，而python始终记录变量最新的值


与编译型语言的区别：
Python中，变量定义不需要指定类型的，当用变量的时候，必须要给这个变量赋值

变量命名规则
1、Python语言
（1）允许采用大写字母、小写字母、数字、下划线(_)和汉字（尽量不用）等字符及其组合给变量命名
如：hello = 100, hello_world = 100, count2 =100
（2）名字的首字符不能是数字，中间不能出现空格，长度没有限制
（3）标识符对大小写敏感，python和Python是两个不同的名字
（4）保留字，也称为关键字，指被编程语言内部定义并保留使用的标识符。程序员编写程序不能定义与保留字相同的标识符。


为什么不能使用关键字？
每种程序设计语言都有一套保留字，保留字一般用来构成程序整体框架、表达关键值和具有结构性的复杂语义等。掌握一门编程语言首先要熟记其所对应的保留字。

python中使用变量的注意点

注意： 在python中，变量一定是要先定义并赋值，才能使用

message="hello world ,Python"
print(message)

变量赋值

• Python语言中，= （一个等号）表示“赋值”，即将等号右侧的值计算后将结果给赋给左侧变量，包含等号（=）的语句称为“赋值语句”
• 语法：<变量> = <表达式>
• 同步赋值语句：同时给多个变量赋值<变量1>, …, <变量N> = <表达式1>, …, <表达式N>也允许连等 比如，x=y=z=1
• 例：将变量x,y交换采用单个赋值，需要三行语句：t=x x=y y=t，采用同步赋值语句，仅需要一行代码：x,y=y,x(不建议这样写)

a='test'
aa=1
b=2
x,y=a,b
x
ya=1
b=2
a,b=b,a
print(a)
print(a,b)

• 常量
• 基本数据类型
• 运算符
• 数值类型标准类型函数
• I/O操作
  Python没有内置常量类型，但是在习惯上会用全大写来表示将某个变量视为常量，这个就需要程序员自行保证不会修改它的值。
  MAX_CONNECTIONS = 5000

2.2 数据类型

python有五种基本的数据类型
Numbers（数值）
String (字符串)
List（列表）
Tuple（元组）
Dicitonary（字典）

注意：
1） 整数一般以十进制表示，但是Python 也支持八进制（“0” 开始）或十六进制（“0x”或“0X” 开始）来表示整数。
2）整数的范围取决于机器32位还是64位，在32机器上，整数的位数为32位，在64位系统上，整数的位数为64位

基本数据类型-数值类型
Python 中可以对数值进行数学运算，比如加减乘除

• 乘方由 ** 表示
• 任意两数相除，结果一定是浮点数
• 两数运算，只要有一个操作数为浮点数，结果一定是浮点数
• Python 书写很大的数时，可以使用下划线将其中的数字分组(仅限Python>=3.6)
  

# 尝试给出运算结果
2+3 # 5
2-3.0 # -1.0
2*3 # 6
3/2 # 1.5
3**3 # 27
4/2 # 2.0

2.3Python中的注释

Python中的注释

• python中的单行注释是#
• 多行注释的时候每行都写一个#，或者采用连续的三个单引号。
• 三个引号不仅能起到多行注释的作用，还能定义多行字符串

# 这是单行注释'''
这是多注释（第一行）
这是多注释（第二行）
这是多注释（第三行）
'''a = """这是一个多行数据且数据格式原样输出，不需要手打输入换行符。"""print(a)
'''
同时也能当作注释符使用，
print("不会输出")
'''
print("end")

2.4 运算符

运算符

1. 算术运算符：+，-，*，**，/，%（取余数），// （往小的方向取整数）
2. 赋值运算符：=，+=，-=，/=，*=，%=
3. 关系运算符：>,>=,<,<=,!=,==
4. 逻辑运算符：逻辑与and，逻辑或or，逻辑非not

print 5/2
print 5.0/2
print 5//2
print 5.0//2
print 2**3a = 1
a += 3
print aa= 1
a-=1
print aa = 1
a*=8
print aa= 10;a /=2
print a'''
&(AND) 
^(XOR)
|(OR)
'''1&1 =1 
1&0 = 01^1=0 
1^0=1
0^0=11|1=1
1|0=1
0|0=0'''
不等运算符
在python3中去掉了<>,只有!=符号表示不等。
比较运算符
== #用来判断两边的参数是否相等位移运算符
<< # 右移运算符
>> # 左移运算符
可以理解为尖尖对着哪边，就往哪边为位移
1<<1 相当于乘以2
1>>1 相当于除以2
'''
# 向左移1位 0000 0000 --》 0000 0010（2）
1<<1
# 向左移2位 0000 0001 --》 0000 0100（4）
1<<2
# 向左移动2位 0000 0010 --》 0000 1000（8）
2<<2

2.5 数值类型标准类型函数

数值类型标准类型函数

1. 标准类型函数（str和type）:可以用于所有的标准类型
2. 转换工厂函数（int,long,float,bool和complex）
3. 功能函数（abs,divmod,pow和round）
4. 进制转换函数（hex,oct）
5. ASCII 转换函数（chr，ord）
   
   

相关拓展模块：decimal，array，math，random， operator

divmod(10,3)
pow(3,3)
round(3.1454543,3)import math
for i in range(5):print(round(math.pi,i))hex(16)
hex(10)
oct(7)
oct(8)
oct(9)
ord('a')
chr(97)'''
标准类型函数（str和type）：可以用于所有的标准类型
str() 将对象转换其字符串表现形式
int() 将一个字符串或数字转换为整型，返回整型数据int(x,base=10) base--进制数，默认十进制
'''int('0xa',16)
int(3.6)
int('12',16)'''
type(object) # 接受一个对象作为参数，并返回它的类型。他的返回值是一个类型对象
'''
type(3) # <class ‘int’>
type(3.13141) # <class ‘float’>'''
转换工厂函数(int, long, float, bool和 complex)
功能函数(abs, divmod, pow和 round)
'''
abs(-3.4) # 取绝对值
divmod(10,3) # 把除法和取余运算结合起来，返回一个包含商和余数的元组
pow(3,3) #幂函数 **
round(3.123,2)
round(3.15678,3) #对前面的数值对应的四舍五入

缩进控制
python有两大特性，一是简洁，二是可读性好。Python代码块缩进完全能够清楚表达一个语句使用那块代码块。

• Python语言采用严格的”缩进“，来表明程序的格式框架。缩进指每一行代码开始前的空白区域，用啦表示代码之间的包含和层次关系
• 一个缩进=4个空格
• 缩进是Python 语言中表明程序框架的唯一手段

2.6 I/O操作

I/O操作
输入Input：
input: python3中接收字符串;


输出数据：print()函数
print()函数用于输出运算结果，根据输出内容的不同，有多种用法

• 第一种，仅用于输出字符串，使用方式如下：print(<待输出字符串>)
• 仅用于输出一个或多个变量，使用方式如下：
  print(<变量1>, <变量2>,…, <变量n>)
• 格式化输出
  print(‘<输出字符串模板>’%(<变量1>, <变量2>,…, <变量n>))

python字符串格式化语法较多，不便记忆，可以在具体需要使用的时候再查询即可

#　输入
name = input("请输入你的姓名")
print(name,type(name))# 输出
print("世界和平")
a="和平世界"
print(a)value1 = 123321
value2 = '滴滴滴'
value3 = 0.23
print(value1,value2,value3)# 格式化输出
a,b = 123.45,1024
print("数字%f和数字%d的乘积是%f"%(a,b,a*b))

I/O操作练习
需求: 输入某学生的三门课程成绩，计算出该学生的总成绩sumScore和平均成绩avg_score(保留两位小数点)。 %.2f

# 题一
course1= input("请输入成绩1")
course2= input("请输入成绩2")
course3= input("请输入成绩3")sum_score = course1 + course2 + course3
avg_score = sum_score/3# 题二
fahrenheit = input("请输入华氏温度")
print("%f华氏度等于%f摄氏度"%(fahrenheit,(fahreheit-32)/1.8))

二、字符串

1、字符串操作

获取终端操作
字符串类型是Python里面最常见的类型。字符串是字符的序列表示，根据字符串的内容多少的分为单行字符串和多行字符串。
可以简单地通过在引号间（单引号，双引号和三引号）包含字符的方式创建它。


第一种方式：str1 = 'our company is westos'
第二种方式：str2 = "our company is westos"
第三种方式：str3 = """our company is westos"""

# 试试看会输出什么
print('这是"单行字符串"')
print("这是'单行字符串'")
print("""这是'多行字符串'的第一行
这是'多行字符串'第二行""")
print('''这是"多行字符串"的第一行
这是"多行字符串"的第二行''')

字符串类型

• 单行字符串可以由一对单引号(')或双引号(")作为边界来表示，单引号和双引号作用相同。
• 多行字符串可以由一对三单引号（‘’‘）或三双引号（“”"）作为边界来表示，两者作用相同。
• Python语言转义字符：\（一个反斜线加一个单一字符可以表示一个人特殊字符，通常是不可打印的字符）
• 例如：\n表示换行、\表示反斜杠、\'表示单引号、\"表示双引号、\t表示制表符（TAB）等

字符串操作符

• 针对字符串，Python语言提供了几个基本操作符

操作符	描述
x+y	连接两个字符串x与y
x*n或n*x	复制n次字符串x
x in s	如果x是s的字串，返回True,否则返回False

name = "Python语言"+"程序设计" # 字符串连接
print(name)name = "这是测试"*3 # 复制3次字符串
print(name)name = "这一门编程语言叫做python"
"语言" in name
"A" in name

序列操作符（索引）

• 字符串是一个字符序列：字符串最左端位置标记为0，依次增加。对字符串中某个字符的索引被称为索引。索引的使用方法如下：<字符串或字符串变量>[序号]
• 如果字符串长度为L，正向递增需要以最左侧字符序号为0，向右依次递增，最右侧字符需要和为L-1;反向递减序号以最右侧字符序号为-1，向左依次递减，最左侧字符序号为-L。
• 字符串以Unicode编码存储，字符串的英文字符和中文字符都算作1个字符。
  

xstr = "Computer Program"
xstr[4] # 获取字符串第五个字符
xstr[-5] # 获取字符串倒数第5个字符x = "青青子衿，悠悠我心"
x[-5] # 获取字符串倒数第五个字符
x[5] # 获取字符串第六个字符

序列操作符（切片）

1. 切片S[i;j]提取对应的部分作为一个序列：i表示开始的位置（索引值，0开始），j表示结束位置（索引值j的前一个字符）
2. 如果没有给出切片的边界，切片的下边界默认为0，上边界为字符串的长度；
3. s[:]获取从偏移量为0到末尾之间的元素，是实现有效拷贝的一种方法；
4. 扩展的切片S[i:j:k],其中i,j含义同上，k为递增步长

s = "hello" # 切片原则：左闭右开
print(s[1:3]) # 从索引值为1的字符开始，按顺序读取到索引值为3的前一个字符
print(s[2:-1]) #从索引值为2的字符开始，按顺序读取到索引值为-1的前一个字符
print(s[1:]) # 从索引值为1的字符开始，按顺序读取后面的所有字符
print(s[:3]) # 从索引值为0的字符开始，按顺序读取到索引值为3的前一个字符print(s[:]) # 读取整个字符串
print(s[::2]) # 索引值为0的字符开始，每隔一个字符读取下一个字符
print(s[::-1]) # 逆序读取字符串

练习
问题1：该代码输出结果为？
print("*"*5 + "This is test" + "*"*5+"\n"+"python\\n")
问题2：该代码输出结果为？
python s ='python' print(s[::-2]) print(s[-6:6])
问题3：如果我要输出如下字符，可以怎么做？

# 题1
print("*"*5 + "This is test" + "*"*5+"\n"+"python\\n")
# 输出结果
'''
*****This is test*****
python'''# 题2
s ='python'
print(s[::-2]) # nhy
print(s[-6:6]) # python# 题3
name = "Let's say:"+"day day up!"*3

2、字符串内建函数

字符串的判断与转换

注意:
title：标题需要每一个首字母大写，e.g.Hello Python
space：空格指的是广义的空格， e.g: \n,\t

str = "hello world"
print(str.capitalize())

字符串的开头和结尾匹配

filename = "hello.log"
if filename.endwith(".log"):print(filename)
else: print("error file")url1 = "file:///mnt"
url2 = "ftp://172.25.254.250/pub/"
url3 = "http:///172.25.254.250/index.html"if url.startswith("http://"):print("爬取网页......")
else: print("不能爬取网页")

字符串的数据清洗

字符串的位置调整

s="Python"
width = 10
result = s.center(width)
print(result)
result = s.ljust(width)
print(result)

字符串的搜索、统计

• str:要查找的子字符串。
• start（可选）:搜索的起始位置，默认为0
• end（可选）:搜索的结束位置，默认为字符串的长度

text = "Python is a powerful programming"
substring = "powerful"
position = text.find(substring)
print(position)

字符串的分类与拼接

text = "Python is a powerful programming language,"
print(text.split())

练习
1、实操练习字符串函数

• len() 返回字符串的字符数
  max() and min() 返回最大或者最小的字符,(按照 ASCII 码值排列)
  split
  count
  replace
  center
  strip
  join

2、以表格的形式整理课件上所述字符串内建函数

'''
str.split(sep)能够根据sep分隔字符串str，分割后的内容以列表类型[]返回。
str.count(sub)方法返回字符串str中出现sub的次数，sub是一个字符串。
str.replace(old,new)方法将字符串str中出现的old字符串替换为new字符串，old和new的长度可以不同。str.cneter(width,fillchar)方法返回长度为width的字符串，其中，str处于新字符串中心位置，两侧新增字符采用fillchar填充，当width小于字符串长度时返回str。其中，fillchar是单个字符。str.strip(chars)从字符串str去掉在其左侧和右侧chars中列出的字符。chars是一个字符串，其中出现的每个字符都会被去掉。str.join(iter)中iter是一个具备迭代性质的变量，该方法将str字符串插入iter变量的运算之间，形成新的字符串。
'''"Python is an excellent language.".split()
"Python is an excellent language.".split('a')
"Python is an excellent language.".split('an')"Python is an excellent language.".count('a')"Python is an excellent language.".replace('a','#')
"Python is an excellent language.".replace('Python','C')"Python".center(20,"=")
"Python".center(2,"=")"	==Python==	".strip('	')
"	==Python==	".strip('	=')
"	==Python==	".strip('	=n')" ".join('PYTHON')
",".join('12345')
",".join(['1','2','3','4','5'])

3、格式化字符串

3.1 在字符串中使用变量

f字符串

• 要在字符串中插入变量的值，可在前引号前加上字母f,再将要插入的变量放在花括号内。这样，当Python显示字符串时，将把每个变量都替换为其值
• f字符串是Python3.6引入的。如果使用的是Python3.5或更早的版本，需要使用fomat()方法，二非这种f语法

first_name="ada"
last_name="tom"
full_name = f"{first_name} {last_name}"
print(full_name)message = f"Hello,{full_name.title()}!"
print(message)

3.2 format()方法的基本使用

format，用于混合输出字符串与变量值，使用方式如下：
print(<输出字符串模板>.format(<变量1>, <变量2>,…, <变量n>))

a,b = 123.345,1024
print("数字{}和数字{}的乘积是{}".format(a, b, a*b))# %格式化可以满足大多常用的功能，format()是python的一个内置函数，其使用频率不高
a,b = 123.345,1024
print("数字%f和数字%d的乘积是%f"%(a, b, a*b))

.字符串format()方法的基本使用格式是：
<模板字符串>.format(<逗号分隔的参数>)

• 其中，模板字符串是一个由字符串大和替换域组成的字符串，用来控制字符串和变量的显示和效果。替换域用大括号({})表示，对应format()方法中逗号分隔的参数。
• 如果模板字符串有多个替换域，且替换域内没有指定序号，则按照替换域出现的顺序分别对应.format()方法中的不同参数
• 可以再模板字符串替换域中指定序号，从而获取format()中对应参数的内容，format()中的参数序号从0开始编号
• 使用format时，想输出“{”和“}”时，双写即可
• 可以再模板字符串替换域中指定format()参数中的变量名，来获取format()参数中变量所存储的内容

"{}曰：学而时习之，不亦说乎。".format("子")
"{}曰：学而时习之，{}。".format("子","不亦说乎")
"{1}曰：学而时习之，{0}。".format("不亦说乎","子")
"{1}曰：{{学而时习之，{0}}}。".format("不亦说乎","子")
"{x}曰：学而时习之，{y}。".format(y="不亦说乎",x="子")

format()方法的格式控制

• format()方法中模板字符串的替换域除了包括参数序号，还可以包括格式化控制信息。
• 其中格式化控制标记用来控制参数显示时的格式。格式控制标记包括：<填充><对齐><精度><类型><宽度>,等字段，这些字段都是可选的，可以组合使用
  
• <填充>、<对齐>和<宽度>主要用于对显示格式的规范。
• 宽度指当前替换域的设定输出字符宽度，如果该替换域参数实际值比宽度设定值大，则使用参数实际长度。如果该值的实际位数小于指定宽度，则按照对齐指定方式在宽度内对齐，默认以空格字符补充。
• 对齐字段分别使用<、>和^三个符号表示左对齐、右对齐和居中对齐。
• 填充字段可以修改默认填充字符，填充字符只能有一个。

• <.精度><类型>主要用于对数值本身的规范
• <.精度>由小数点（.）开头。对于浮点数，精度表示小数部分输出的有效位数。对
  于字符串，精度表示输出的最大长度。小数点可以理解为对数值的有效截断。

"{:.2f}".format(12345.6789)
"{:>25.3f}".format(12345.6789)
"{:.5}".format("基本数据类型")

• <类型>表示输出整数和浮点数类型的格式规则。
• 对于整数类型，输出格式包括6种：
  • b: 输出整数的二进制方式；
  • c: 输出整数对应的Unicode字符；
  • d: 输出整数的十进制方式；
  • o: 输出整数的八进制方式；
  • x: 输出整数的小写十六进制方式；
  • X: 输出整数的大写十六进制方式；

• 对于浮点数类型，输出格式包括4种：
• e: 输出浮点数对应的小写字母e的指数形式；
• E: 输出浮点数对应的大写字母E的指数形式；
• f: 输出浮点数的标准浮点形式；
• %: 输出浮点数的百分形式。

"{0:e},{0:E},{0:f},{0:%}".format(3.14)
"{0:.2e},{0:.2E},{0:.2f},{0:.2%}".format(3.14)# 常用的format()方法格式控制信息
"{:.2f}".format(3.1415926) # 输出小数点后两位"{:x}".format(1010) #输出整数的十六进制形式"{:.5}".format("这是一个很长的字符串") # 输出字符串的前5位"{:-^10}".format("PYTHON") # 居中并填充

问题1：该代码输出结果为？
print( "{0:-^15,}".format(1234567890))

print( "{0:-^15,}".format(1234567890))
# 输出 -1,234,567,890-

三、列表与元组

1、序列

数据结构
通过某种方式（例如对元素进行编号）组织在一起的数据元素的合集，
这些数据元素可以是数字或者字符，甚至可以是其他数据结构。
在Python中，最基本的数据结构是序列（sequence）。序列中每个元素被分配一个序号即元素的位置，也称为索引。第一个索引是0，第二个则是1，以此类推。
序列数据类型包括：字符串、列表和元组类型。

通用序列操作

1. 索引：序列中所有元素都是有编号的——从0开始递增。这些元素可以通过编号分别访问。
2. 分片：与使用索引来访问单个元素类似，可以使用分片操作来访问一定范围内的元素。分片通过冒
   号相隔的两个索引来实现。[i : j: k]
3. 序列相加：通过使用加号可以进行序列的连接操作。(用于同序列类型的连接操作)
4. 乘法：用一个数字x乘以一个序列会生成新的序列，而在新的序列中，原来的序列将被重复x次。
5. 成员资格：为了检查一个值是否在序列中，可以使用in运算符或者not in运算符。该运算符检查某
   个条件是否为真，然后返回相应的值。（条件为真返回True，条件为假返回False）
6. 长度、最小值和最大值：内置函数len、min和max。len函数返回序列中所包含元素的数量，min
   函数和max函数则分别返回序列中最大和最小的元素。

2、列表

列表的创建
数组：存储同一种数据类型的集合。scores=12,95.5
列表（加强型数组）：和字符串不同，列表可以包含任何种类的对象：数字、字符串甚至其列表。

• 定义一个空列表：a = []
• 定义一个包含数据的列表：b = ['a',1,'b']
• 定义一个嵌套子列表的列表：[1,2,3,['a','b','c'],'q','a']

列表的访问
列表是有序集合，因此要访问列表的任何元素，只需将该元素的位置或索引告诉Python即可（索引）。
要访问列表元素，可指出列表的名称，再指出元素的索引，并将其放在方括号内。列表名[索引值]
分片：列表名[索引起始值：索引结束值]（注意：输出的结果不包含索引结束值指向的元素）

info = ['This','is','test']
print(info[1])
print(info[-1])
info
info[:]
info[1:2]

列表的相加与乘法
两个列表进行相加，可以实现对两个列表的合并
使用一个列表与数字进行相乘，可实现对列表内容的复制

a = [1,2,3,4,5,6,7]
b = ['x','y','z']
c = a+b
print(c)a = [1,2,3,4,5,6]
print(a*2)
print(a*3)

列表的成员判断
使用关键字in或者not in，来判断一个值，是否属于该列表中的成员
not in 用来确定，某个值不存在于列表中

a =  ['This','is','test',1,2,3,'x','y']
'This' in a
'1' in ab = ['Python',1,'x']
'x' not in b
2 not in b

修改列表的元素
列表可以使用所有适用于序列的标准操作。同时列表也属于可变对象（可以在原位置对数据进行操作）
修改列表元素的语法与访问列表元素的语法类似。要修改列表元素，可指定类别名和要修改的元素的索引，再指定该元素的新值。

a = ['1','2','3']
a[1] = 'x'
ab = ['1','2','3','4','5','6']
b[3:6] = ['x','y','z']
b

删除于添加列表的元素
若需要删除列表中指定元素，可以使用del关键字
同样，可以借助分片，来删除元素

b = ['1','2','3','4','5','6']
del b[3]
del b[0:3]a = [0,1,2,3,4,5,6,7,8]
a[2:4] = []
#借助分片插入数据
a[2:2] = [2,3]

方法：列表的添加
列表可通过append追加一个元素到列表中；
思考：如果我想添加多个元素呢？append方法可以实现么？

L = ['good','job']
L.append('!!!')
L
L.append(['the','other','list'])
L

方法：列表的拉伸
列表可通过extend方法在列表的末尾一次性追加另一个序列中的多个值。换句话说，可以用新列表扩展原有的列表

x = ['This','is']
x.extend(['python'])
xa = ['1','2','3']
b = ['x','y','z']
a.extend(b)
a

方法：在列表中的插入元素
使用方法insert() 可在列表的任何位置添加新元素。为此，你需要指定新元素的索引和值。L.insert(index,object)

xnum.insert(2,'ddd')
xnum
xnum.insert(2,['x','y'])
xnum

方法：获取元素索引值
使用index方法，可以获取列表中某个元素的索引值
L.index(x,[,start[,end]])
其中，start和end为可选参数，指定起始和结束位置

a = [0,1,2,3,4,5,6,7,8,'x','y','z']
a.index('x')
a.index('x',0,10)

方法：计算列表中某个元素出现的次数
使用count()方法，可获利列表中某个元素在列表中出现的次数

a = [0,1,2,3,'x',5,'x',7,8,'x','y','z']
a.count('x')

方法：列表的删除
list.pop()根据元素的索引值进行删除指定元素。
pop方法。在会移除列表中的一个元素（默认是最后一个），并且返回该元素的值
使用pop方法可以实现一种常见的数据结构——栈。栈的原理就像堆放盘子那样。只能在顶部放一个盘子，同样，也只能拿走一个盘子。最后放入堆栈的最先被移除（这个原则称为LIFO，即后进先出）。
思考：pop方法和del方法的区别是什么？

a = [0,1,2,3,'x',5,'x',7,8,'x','y','z']
a.pop(3)x=[1,2,3]
y = []
y.append(x.pop())
y# list.remove()删除列表中指定元素（和del的差别是什么？）
a.remove('x')
# list.clear.清空列表里面的所有元素
a.clear()

方法：列表的翻转与排序
reverse方法将列表中的元素反向存放
sort方法用于原位置对列表进行排序，在“原位置排序”意味着改变原来的列表，从而让其中的元素能按一定的顺序排列，而不是简单地返回一个已排序的列表副本。

b = ['x','y','z',1,2,3]
b.reverse()a=['x','z','y']
a.sort()
a = [2,10,11,5,6]
a.sort()

总结

练习

• 问题一：a = [‘good’,‘bad’,‘nice’,‘terrible’]
  使用三种方法，在列表a最后面添加一个元素 ‘nothing’
• 问题二：a = [‘good’,‘bad’,‘nice’,‘terrible’]
  利用列表的index方法，将列表a中的元素’bad’改为’noting’
• 问题三：a = [‘1’,‘2’,‘3’,‘4’,‘5’]
  将列表a中索引1-3的元素移动到列表a的尾部

# 题1
a = ['good','bad','nice','terrible']
a.appened('nothing')
a.extend('nothing')
a,insert('nothing')# 题2
a[a.index('bad')] = 'nothing'# 题3
a = ['1','2','3','4','5']
# 使用切片
a = a[0:1]+a[4:]+a[1:4]
a

3、元组

元组：带了紧箍咒的列表
元组由不同的元素组成，每个元素可以存储不同的类型的数据，如字符串、数字和元组等等
元组使用括弧“()”来阶段；元组中各元素之间使用逗号隔开。元组不支持修改或删除其所包含的元素。
元组也是一种序列，可以利用序列操作对元组进行处理
元组好比是一个只读的列表，只能获取数据，不能对数据进行修改

元组与列表一样，也是一种序列，唯一的不同是元组不能修改。创建元组的语法很简单：如果用逗号分隔了一些值，那么你就自动创建了元组。

# 定义空元组
tuple = ()
# 定义单个值的元组
tuple = (fentiap,)
# 一般的元组
tuple = (fentiao,8,male)

元组使用场景：

1. 字符串的格式化输出，print(“姓名：%s 年龄：%d” %(“李四”，20))
2. 函数返回多个值，可以通过元组完成。

my_tuple = (1,2,'a','b')
# 提示：元组定义完成以后，元组里面的数据就不能进行修改，只能获取数据
print(my_tuple,type(my_tuple))
# 根据下标可以获取元组中的某个数据
result = my_tuple[2]
print(result)
# 根据切片取值
result = my_tuple[:2]
print(result,type(result))
# 错误的演示：不能根据下标修改元组中的数据
# my_tuple[-1] = 'c'# 提示：元组如果只有一个数据，那么逗号不能省略
name_tuple = (1,)
print(name_tuple,type(name_tuple))

元组和列表之间的关键不同：

• 元组是不可更改的，元组创建之后，元组就不能修改、添加、删除成员。
• 元组上述特点使得其用于处理数据时效率交给，而且可以防止出现误操作修改操作。

元组特性
特性：同样支持连接操作符、重复操作符、成员操作符、索引、切片操作
注意：不能对元组的值任意更改；

元组创建
用一对圆括号将逗号分隔的若干数据（表达式的值）括起来。

tuple1 = ('a',200,'b',150,'c',100)
tuple2 = (3.14,1.61,0,-9,6)
tuple3 = ("a","b","c","d")
tuple4 = tuple(); # 创建空元组
tuple5 = ("a",) #创建单一元素的元组
tuple5

元组访问
元组的访问和列表一样，可以通过索引来访问元组的成员

vehicle=('train','bus','car','ship','subway','bicycle')
vehicle[1]
vehicle[0:3]

元组运算
元组相加：通过元组相加的方法生成新元组。
元素相乘：用数字n乘以一个元组，会生成一个新元组。在新元组中，原来元组将被重复n次。

vehicle1 = ('train','bus','car','ship')
vehicle2 = ('subway','bicycle')
vehicle1 + vehicle2vehicle=('train','bus','car','ship')
vehicle*2
vehicle=(('train','bus'),'car','ship')*2

元组操作
对元组分别赋值，引申多个变量也可通过元组方式分别赋值
原则上，是无法对元组内的元素进行操作的。但硬刚不行，就绕着干。
通过引入第二个元组以及切片的方式对元组元素进行操作
删除元组中某个元素

a = (1,2,3)
x,y,z = a
x
y
za = (1,2,3,4,5,6,7)
b = a[0:4]+a[5:]
b

元组的方法与可用函数
t.count(value) --> int：返回value在元组中出现的次数；
t.index(value)：返回value在元组中的偏移量（即索引值）
tuple()：把一个可迭代对象转换元组
len(变量)：返回长度
max(变量)：返回最大值
min(变量)：返回最小值
sum(变量)：变量内部元素相加
sum(变量，数值)：变量内部元素相加 +数值
sorted(变量)：将变量内部元素排序
reversed(变量)：返回一个迭代器对象，使用list(reversed(变量))就可返回将变量元素翻转

列表与元组之间的转换
列表转换为元组
python中tuple()函数可以接受一个列表，并返回一个包含同样元素的元组
python中list()接受一个元组，并返回一个包含同样元素的列表
从结果上看，tuple()函数冻结了列表，而list()融化元组

vehicle=['train','bus','car','ship','subway','bicycle']
aa = tuple(vehicle)
aa
bb = list(aa)
bb

4、For循环和Range序列

for循环语句语法结构
与传统语言(e.g.C/C++,Java )中的 for 语句不同, Python 的 for语句更加简洁

# 序列类型for循环
for item in 'hello':print("字符显示："，item)a = (1,2,3,4,5,6)
for item in a :print(item)a = [4,5,6,7,8]
for item in a:print(item)

Range序列说明
官方有明确划分的——有三种基本的序列类型：列表、元组和范围（range）对象
range()方法生成一段左闭右开的整数序列
range语法：
range(start,end,.step=1)返回一个包含所有k的列表，start < k < end,k每次递增step,.start指的是计数起始值，默认是0；stop指的是计数结束值，但不包括stop;step是步长，默认为1，不可以为0

例如：
range(0,5) 生成了数字序列 0 1 2 3 4
range(1,10,2) 生成了数字序列 1 3 5 7 9
range(6, 1, -1) 生成了数字序列 1 3 5 7 9


range()方法生成的数字序列可以进行判断元素，查找元素，切片等操作，但不能修改元素，也不支持进行加法拼接与乘法重复
range产生的序列无法直接打印，必须将range()放在list中调用，才能一次性显示它所有的内容

print(list(range(6)))

练习
需求1： 求1～100之间所有偶数的和;
需求2： 求1～100之间所有奇数的和;
需求3： 用户输入一个整形数， 求该数的阶乘; 3!=3*2*1=6

---

# 需求1
for i in range(1,100,2):sum += iprint(sum)
# 需求2
for i in range(0,100,2):sum1 += iprint(sum1)
# 需求3
num = int(input("请输入一个正整数："))
for i in range(1,num+1):result *= iprint(result)

总结

Python作为一种易学易用的编程语言，在当今数字化时代具有广泛的应用。本文旨在帮助初学者快速入门Python编程，并了解其基本原理和应用场景。

在本文中，我们先介绍了Python的背景和特点，解释了为什么它成为最受欢迎的编程语言之一。接着，我们逐步引导读者了解Python的基本语法、数据类型、条件语句和循环结构等基础知识。

通过本文的学习，你将对Python编程有一个全面的了解，并能够开始自己的编程之旅。无论你是对编程充满好奇，还是希望通过编程解决实际问题，学习Python都是一个绝佳的起点。让我们一起探索Python的奇妙世界吧