#### 认识和了解Python
#### 第一个Python程序
- 安装Python
- 配置环境变量
- 编写Python程序的方法
- DOS下编写
- 记事本编写
- IDE编写
#### Python中的注释
- 作用
- 用来给程序员看的，增强文件可读性来使用的
- 分类
- 单行
- 多行(文档)
- 问题
- 支持中文，如果出现问题，可以尝试在首行加入coding = 'utf-8'解决
#### 变量以及类型
- 定义/初始化/赋值
- 使用案例
```
#实现购物小票
```
- 变量类型
- int
- float
- bool
- complex
- str
- list
- tuple
- dict
- set
- 变量使用的注意事项：
- 注意:定义变量的时候，而且它已经有数据的情况下，系统自动决定了它的类型
如果想查看变量的类型，可以使用 type(变量名)进行查看
#### 标示符和关键字
- 概念
- 开发人员在程序中自定义的一些符号和名称
如变量名、函数名、类名
- 规则
- 由字母(包括中文)、下划线和数字组成，且数字不能开头
不能为系统关键字、大小写敏感
- 技巧
- 见名知意
- max_value
- 驼峰命名
- 大驼峰
- UserName
- 小驼峰
- userName
- 下划线连接
- user_name
- 关键字
- 关键字罗列
- and as assert break class continue def del elif else except exec finally for from global if in import is lambda not or pass print raise return try whilewith yield
- 关键字查询
- import keyword
- keyword.kwlist
#### 输出
- 普通的输出
```
print("Helloworld")
```
- 格式化输出
```
print("我今年10岁")
print("我今年11岁")
print("我今年12岁")
//格式：
age = 10
print("我今年%d岁"%age)
name="小明"
print("我的名字叫:%s,今年%d岁"%(name,age))
```
- 常见格式输出：
- %d / %i 有符号的十进制整数
- %u 无符号的十进制整数
- %o 八进制整数
- %x 十六进制整数
- %f 浮点数
- %g %f的简写
- 换行输出"\n"
```
print("我的名字叫:%s,\n今年%d岁"%(name,age))
```
- 练习
- 完成自我介绍的输出（制表符 "\t"）
#### 输入
- raw_input()
- input()
#### 运算符
- 算术运算符
- ‘+’ ：加
- ‘-’ ：减
- ‘*’ ：乘
- ‘/’ ：除
- ‘//’ ：取整除
```
9 // 2 = 4
9.0 // 2.0 = 4.0
```
- ‘%’ ：取余
- ‘**’ ：幂
```
2 ** 3 = 8
```
- 赋值运算符
- 单独的赋值运算符
- ‘=’： 赋值
```
a = 20,b,c = 2,3
```
- 复合赋值运算符
- ‘+=’ :
```
a += b等价于 a = a + b
```
- ‘-=’ :
- ‘*=’ :
- ‘/=’ :
- ‘%=’ :
- ‘**=’ :
- ‘//=’ :
#### 数据类型转换
- int(x,[,base]) 将x转换为一个整数
- float(x) 将x转换为一个浮点数
- complex(real,[,imag]) 创建一个复数
- str(x) 将x转换为字符串
- repr(x) 将对象x转换为表达式字符串
- eval(str) 用来计算在字符串中的有效python表达式，并返回一个对象
- tuple(s) 将序列s转换为一个元组
- list(s) 将序列s转换为一个列表
- hex(x) 将一个整数转换为一个十六进制的字符串
- oct(x) 将一个整数转换为一个八进制的字符串
#### 判断语句介绍 if
- 语法：
```
if 要判断的条件:
条件成立时，要做的事情
例：如果你的年龄满18岁了，可以做点什么
```
注意：代码的缩排，可以使用tab键完成
- 练习：（import random）
```
生成一个随机值，完成骰子结果大还是小的展示
```
#### 比较、关系运算符
- == :检查两个操作数的值是否相等，如果相等返回True，否则返回False
- != :检查两个操作数的值是否相等，如果值不等，则条件为True
- ‘>=’ :
- ‘<=’ :
- ‘> ’ :
- ‘< ’ :
#### 逻辑运算符
- and : 与 表达式1 and 表达式2 两个表达式都成立，结果为True
- or : 或 表达式1 and 表达式2 两个有一个表达式成立，结果为True
- not : 非 not 表达式 与表达式的值相反
#### 推荐书籍
- - 电子书
#### if-else
- 语法格式：```
if 条件：
满足条件要做的事情1
满足条件要做的事情2
满足条件要做的事情3
...
else:
不满足条件要做的事情1
不满足条件要做的事情2
不满足条件要做的事情3
...
```
- 案例
- 骰子大小
- 用户登陆#### if-elif-else
- 使用场景：
- 如果满足条件1时，做事情1
- 如果满足条件2时，做事情2
- 否则，做事情3
- 语法格式：```
if 条件1:
事情1
elif 条件2：
事情2
else:
事情3
```
- 案例练习：
- 练习1：季节划分
- 练习2：分数评级
- 注意事项;
- elif不能单独使用
#### if的嵌套
- 使用场景（进地铁站）```
if 安检合格：
可以进入地铁站
if 有地铁卡：
直接刷卡进站
else:
购买临时卡
else ：
接受检查
```- 语法格式
```
if 条件1
满足条件1做的事情
if 条件2
满足条件2做的事情
```- if嵌套案例
- 用户登陆(密码+短信验证码)#### 猜拳游戏（石头、剪刀、布）
- 无嵌套方案1
```
result=input("石头0 剪刀1 布2\n")
computer=random.randint(0,2)
if (computer==0 and result == 2) or (computer == 1 and result == 0)
or (computer == 2 and result == 1):
print("你赢了")
elif computer == result:
print("平局")
else:
print("你输了")
```
- 嵌套方案2```
# 电脑出石头的时候
if cmp == 0:
# 如果你也出的石头
if you == 0:
# 平局
print("平局，都是石头")
# 如果你出的剪刀
elif you == 1:
print("很遗憾，你输了，电脑出的石头，你出的剪刀")
# 如果你出的布
elif you == 2:
print("恭喜，你赢了，电脑出的石头，你出的布")
elif cmp == 1:
if you == 0:
print("恭喜，你赢了，电脑出的剪刀，你出的石头")
elif you == 1:
print("平局，都是剪刀")
elif you == 2:
print("很遗憾，你输了，电脑出的剪刀，你出的布")
elif cmp == 2:
if you == 0:
print("很遗憾，你输了，电脑出的布，你出的石头")
elif you == 1:
print("恭喜，你用了，电脑出的布，你出的剪刀")
elif you == 2:
print("平局，都是布")
```#### 循环语句
- 使用场景
- 四驱车
- 排风扇
- 樱木花道的99次表白
- 结论: 重复的事情，一般都是用循环来解决
- while循环
- while循环语法```
while 条件：
条件满足时，做的事情1
条件满足时，做的事情2
迭代
...
```
- 案例
```
i = 0
while i < 5:
print("i=%d"%i)
i += 1
```
#### while循环的使用
- 求1 + 2 + 3... + 100的和
- 求1 + 2 + 3... + 100所有偶数的和
#### while循环的嵌套以及应用
- 语法格式```
while 条件1：
条件1满足时，做的事情1
条件1满足时，做的事情2
迭代
...
while 条件2：
条件2满足时，做的事情1
条件2满足时，做的事情2
迭代
```- 嵌套循环练习1
```
打印 如下图形
*****
*****
*****
```- 嵌套循环练习2
```
打印 如下图形
*
**
***
****
*****
```- 嵌套循环练习3
#### for循环
- for循环的格式
```
for 临时变量 in range(start,end,step)/Iterable:
循环条件成立执行的代码
else:
循环条件不成立执行的代码
```
#### 循环控制
- break：
- 结束当前循环
- continue：
- 跳过本次循环
- 案例break:```
for ch in "HelloWorld":
print("-------------")
if ch == 'W':
break
print ch
```- 案例 continue:
```
for ch in "HelloWorld":
print("-------------")
if ch == 'W':
continue
print ch
```
- 分别对照结果，思考二者的差别#### 课后练习
```
使用循环、分支完成以下图形的打印
图1：
*
***
*****
图2：
*
***
*****
***
*
```#### 字符串
用来存储用户名、密码的数据
- 字符串格式：
- 双引号或者单引号中的数据，就是字符串
```
name='chenduxiu'
#或者
name="zhendexiu"
```- 字符串输出
- 格式控制符 "%s"```
#例：
name=”xiaoming“
profession ='学生'
address="海淀区神州科技园B座2层"
print '-'*40
print("姓名:%s"%name)
print("职业：%s"%position)
print ("地址:%s"%address)
print ('-'*40)
```- 字符串输入
```
输入的内容 = input("需要输入的内容")
例:通过键盘输入用户名密码
注意：python2的输入为 raw_input()
```- 下标和切片
- 下标索引：就是指的编号，类似超市储物柜的编号，通过编号就能找到对应的东西```
#例如:
name="xiaoming"
aaa=0
count = len(name)
while aaa < count:
print(name[aaa])
aaa+=1
```- 切片
- 字符串，列表，元组都支持切片操作
- 语法```
[起始:结束:步长] 区间位置：左闭右开
```
```
例：
name=‘xiaoming’
print(name[0:2])
打印结果 "xi"
name='0123456789'
print(name[0:2])
#从第二个取到最后
print(name[2:])
#从头开始取，直到索引值为3的位置(不包括该元素)
print(name[:3])
#从索引值为2的位置开始取，直到倒数第一个(不包括倒数第一个)
print(name[2:-1])
#从头开始取，每两个切出一个
print(name[0::2])
#倒序的内容输出
print(name[::-1])
#倒序切出索引5到索引值1中间的数据
print(name[5:0:-1])
```- 字符串常见操作
- find/rfind```
#检查str是否包含在str1中，如果是返回开始的索引值，否则返回-1
str1.find()
str1="good good study,day day up"
index = str1.find("stu")
print(index)
```
- index/rindex```
跟find()方法一样，只不过目标字符串如果不在要查找的字符串中会报一个异常
```- count
```
返回str在目标字符串中start-end之间出现的次数
str1="good good study,day day up"
print(str1.count("good"))
```- replace
```
把str1中指定的字符串"good",用“222”进行替换，最多替换2次
str1="good good study,day day up"
print(str1.count("good"))
str2 = str1.replace("good","222",2)
print(str2)
```- split
```
以" "为分割符切片str1
str1="good good study,day day up"
array = str1.split(" ")
print(type(array))
print(array)
```- capitalize
```
把字符串的第一个字符大写
print(str1.capitalize())
```- title
```
把字符串中的每一个单词的首字母大写
print(str1.title())
```- startswith
```
检查字符串是否以指定字符串开头,
是则返回True，否则返回False
例：判断是否为有效网址
```- endswith
```
检查字符串是否以指定字符串结尾,是则返回True，否则返回False
例：判断是否为有效邮箱
```- lower
```
转换字符串中所有的大写字符为小写
```- upper
```
转换字符串中所有的小写字符为大写
```- ljust
```
返回一个原字符串左对齐，并使用空格填充至长度width的新字符
``````
str1 = "hello"
print(str1.ljust(10))
```
- rjust
```
返回一个原字符串右对齐，并使用空格填充至长度width的新字符
``````
str1 = "hello"
print(str1.rjust(10))
```- center
```
返回一个原字符串居中对齐，并使用空格填充至长度width的新字符
str1 = "hello"
print(str1.center(10))
```
- lstrip```
删除目标字符串左边的空格
str1 =" hello "
print(str1.lstrip())
```- rstrip
```
删除目标字符串右边的空格
str1 =" hello "
print(str1.rstrip())
```- strip
```
删除目标字符串两边的空格
str1 =" hello "
print(str1.strip())
```- rfind
```
类似于find()函数,不过是从右边开始查找
```- rindex
```
类似与index()函数，不过是从右边开始查找
```- partition
```
把目标字符串分割成str前，str以及str后三部分，得到一个tuple(元组)
str1="nihaoma"
str1.partition("hao")
('ni', 'hao', 'ma')
```- rpartition
```
从右边开始，把目标字符串分割成str前，str以及str后三部分，得到一个tuple(元组)
str1="nihaoma"
str1.partition("hao")
('ni', 'hao', 'ma')
```- splitlines
```
将目标字符串按照行进行分割,返回一个列表
str1 = "Hello\nWorld"
print(str1.splitlines())
运行结果：
['Hello', 'World']
```- isalpha
```
判断目标字符串中是否所有的字符都为字母，返回True，或者False
str1 = "123Hello"
print(str1.isalpha())
```- isdigit
```
判断目标字符串中是否所有的字符都为数字，返回True或者False
str1 = "123Hello"
print(str1.isdigit())
```- isalnum
```
如果字符串中都是字母或者数字则返回True，否则返回False
str1="abc123"
print(str1.isalnum())
```- isspace
```
如果字符串中只包含空格，则返回True，否则返回False
```- join
```
将字符串或者列表，元组中的每个元素(字符)使用指定字符连接起来
li=["one","two","three"]
str2="_"
str2 = str2.join(li)
print(str2)
```#### 列表介绍
- 引入：
- 如何存储班级中所有同学的名字?- 语法格式：
```
names=["李大钊","陈独秀","蔡元培","陈佩斯"]
#注意：比C语言中的数组功能更强大，列表中的元素可以为不同类型
list1=[10,"人",2.5,True]
```- 访问列表中的元素
- 设置值```
list1[0] = 100
```- 获取值
```
print(list[0])
```- 列表的循环遍历
- 使用for循环进行遍历```
#例：
list1=[10,"人",2.5,True]
for a in list1:
print(a)
```- 使用while循环进行遍历
```
list1=[10,"人",2.5,True]
length = len(list1)
i = 0
while i < length:
print(list1[i])
i += 1
```- 列表的常见操作
- 增
- append```
#通过append向指定列表添加元素
#例：
list2 =["one",2,"san"]
list2.append("four")
print(list2)
#结果：['one', 2, 'san', 'four']
```- extend
```
#通过extend可以将一个列表中的元素逐个添加到另外一个列表中
#例：
l1=[1,2]
l2=[3,4]
l1.extend(l2)
print(l1)
#结果：[1, 2, 3, 4]
```- insert
```
#insert(index,object)在指定的位置处插入元素object
l1=[1,2]
l2=[3,4]
l1.extend(l2)
print(l1)
#结果：[1, [3, 4], 2]
```- 查
- in```
如果存在，则返回True，否则返回False
l1 =[1,2,3,4,5]
print( 1 in l1)
```- not in
```
与in相反
l1 =[1,2,3,4,5]
print(1 not in l1)
```- index
```
返回元素在列表中的索引值
index(obj)
index(obj,fromIndex,toIndex) 区间位置为前闭后开
如果没有列表中不包含查找元素，会报错
```- count
```
#返回元素在列表中出现的次数
list1 = [1,2,3]
print(list1.count(1))
```
- 删
- del```
#根据下标进行删除
#例：
l1 = [2,3,4]
del l1[0]
print(l1)
#结果：[3,4]
```
- pop```
#删除最后一个元素
#例：
l1 = [2,3,4]
l1.pop()
print(l1)
#结果:[2,3]
```- remove
```
#根据元素的值进行删除
l1 = [2,3,4]
l1.remove(2)
print(l1)
#结果:[3,4]
```
- 改```
直接通过下标来修改元素
例:
l1=[1,2]
l1[0] = 100
print(l1)
结果：[100,2]
```- 排序以及列表反转
```
#sort方法将list按特定顺序进行排列，默认为由小到大，参数reverse=True可改为倒序，由大到小
#例:
l1 = [2,4,1,9,23]
l1.sort()
print(l1)
#结果:[1,2,4,9,23]
l1.sort(reverse=True)
print(l1)
#结果为:[23,9,4,2,1]
#反转方法： reverse()
```#### 列表的嵌套
- 概念```
一个列表中的元素，又是一个列表
```- 嵌套列表的遍历
```
l1=[[1,2],4,[5,6]]
for l in l1:
if type(l) == list:
for ll in l:
print(ll)
else:
print(l)
print("-"*10)
```
- 练习```
循环录入3个学生信息(包括name,age)
使用嵌套列表完成学生信息的存储```
#### 元组
- 元组概念```
Python的元组与列表类似，不同之处在于元组的元素不能修改，元组使用“()”
列表使用"[]"
```- 操作
- 访问```
t=(1,2,3)
print(t[0])
修改或者删除元素的话会报错：
t[0]= 10
删除报错：
t.pop()
但是可以变向进行删除
tuple->list(进行删除操作)->tuple
```
#### 字典介绍
- 字典的引入```
#如何存储将多个国家的简称及名字完成对应的存储？
#例如: CN:中国 JP：日本 US:美国
country = {"CN":"中国","JP":"日本"}
```- 字典中元素的访问：
- 直接访问```
print(country['CN'])
打印结果:"中国"
如果没有"CN"这个key，则会报错
```- 通过get方法访问
```
value=country.get('CN')
#这时候value的值为 "中国"
value = country.get('SH','中国')
#这个意思是如果有key ‘SH’则得到对应值，没有的话，得到默认值"中国"
```- 字典的常见操作1
- 修改元素```
可以直接进行修改
student={'name':'陈独秀','age':99}
student['age']=100
```- 添加元素
```
student['address']='北京市朝阳区'
#如果字典中没有'address'这个key，则会将这个元素条件到字典中，如果已经包含这个key
则新值会将旧值覆盖
```- 删除元素
- del 删除```
#例：
#删除某个key
del student['age']
#删除所有的键值对，删除之后，将不能在进行访问
```- clear
```
#清空所有的键值对，清除后依旧可以进行访问
stu.clear()
```
- 字典的常见操作2
- len() 键值对个数的获取```
stu={'name':‘xiaoming’,'age':19}
len(stu)
#长度为2
```- keys()
```
#返回一个字典中所有的key的列表
allKeys= stu.keys()
for k in allKeys:
print(k)
print(allKeys[k])
```- values()
```
#返回一个包含字典所有value的列表
stu.values()
#['xiaoming',19]
```- items()
```
#返回一个包含所有(键、值) 元组的列表
stu.items()
#[('name','xiaoming'),('age',18)]
```- 字典的遍历
- 所有key的遍历```
stu={'name':'xiaoming','age':19}
for key in stu.keys():
print(key)
```
- 所有value的遍历
```
stu={'name':'xiaoming','age':19}
for value in stu.values():
print(value)
```- 所有item的遍历
```
stu={'name':'xiaoming','age':19}
for item in stu.items():
print(item)
```- 所有key和value的遍历
```
stu={'name':'xiaoming','age':19}
for key,value in stu.items():
print(type(value))
print("%s=%s"%(key,value))
```#### 公共方法
- 公共运算符
- '+'```
作用：合并、连接
例:str1="hello"+"world"
结果：”helloworld“
list1=[1,2]+[3,4]
结果：[1, 2, 3, 4]
例：tuple1=(1,2) + (3,4)
结果：(1,2,3,4)
```
- '*'```
作用：复制
例: 'hello' * 2
结果: 'hellohello'
例: [1,2] * 2
结果：[1,2,1,2]
例:(1,2) * 2
(1,2,1,2)
```- in
```
作用：元素是否存在
例：
result = '123' in 'HelloWorld123'
print(result)
result= 1 in [1,2]
print(result)
result = 2 in (1,2)
result = 'name' in {'name':'xxx','age':12}
print(result)
```- not in
```
作用：元素书否不存在，用法跟in 一样
```- python的内置函数
- len```
作用：得到元素的个数
例：len([1,2])
len((1,2))
获取到的为键值对个数
len({'name':'xiaoming','age':18})
```- max(...)
```
作用：获取最大值
例:
max(1,2,3)
max([1,2,3,4])
找字典中的最大键
a =max({'a':1,'b':2,'x':3})
```- min(...)
```
作用: 获取最小值(用法与max一致)
```- del
```
删除元素或者删除容器
del 元素/容器变量名
del list1[0]
del list1
```- 变量.del()
```
#在python3中已经不存在这种用法
list1 = [1,2,3]
list1.del()
```
- 引用的使用
- 什么是引用```
windows中的快捷方式
家庭地址
```- 非引用类型案例：
```
a = 10
b = a
print(id(a))
print(id(b))
b=100
print(a)
print(b)
print(id(a))
print(id(b))
```- 引用类型案例:
```
list1 = [1,2,3]
list2 = list1
print(id(list1))
print(id(list2))
list2[0]=100
print(list1)
print(list2)
print(id(list1))
print(id(list2))
```
- 引用类型内存图分析#### 课后练习
```
有能力的同学用函数完成
学生管理系统：
1.添加学生
2.查询学生
3.删除学生
4.修改学生
5.退出系统
```
扫一扫
4576
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
