python入门笔记

1.python注释 多行注释的话可以选中需要注释的代码,按ctrl+/ 取消注释同理 2.python变量 赋值时就会创建变量，不用声明 要指定类型变量可以强制转换 变量名：区分大小写，必须以字母或者下划线字符开头，不能以数字开头，变量名只能包含字母数字下划线 可以在一行中为多个变量赋值

x=y=z=1

若在列表、元组中有一组值，python允许将值提取到变量中，称为拆包

fruits=['apple','banana','cherry']，x,y,z=fruits

字符串依然可以相加，但字符串和数字不能相加 在函数外部创建的是全局变量，函数内部创建的是局部变量，但若要在函数能创建全局变量可用global关键字 3.python数据类型 用int float 等是可以强制转换的 4.python数字 导入随机数(1-10) 注意：别和range搞混了！ range（5）是生成[0,1,2,3,4]

import random
print(random.randint(1,11))

5.python字符串 切片 注意：第一个字符索引为0

b='hello world'
print(b[2:5])

也可以对切片进行负索引 字符串修改 upper()方法以大写形式返回字符串 lower()同理 转为小写

a='Hello World!'
print(a.upper())

strip()可以删除字符串开头或者结尾的空格

a=' hello world'
print(a.strip())
#输出 'hello world'

replace()方法用一个字符串替换另一个字符串

a='hello world!'
print(a.replace('h','j'))
#输出 'jello world!' 

spilt()返回一个列表，其中指定分隔符之间的文本成为列表项

a='hello,world'
print(a.spilt(','))
#输出['hello','world']

format格式化 我们不能直接字符串+数字会报错，可以用format()方法传参

age=20
txt='昊昊今年{}'
print(txt.format(age))
#输出 昊昊今年20

当然，format也可以接受无限数量的参数

quantity=20
itemno=3000
price=49.95
myorder='李三今年{}岁 买了个华为手机{}元 每个月花费{}元'
print(myorder.format(quantity,itemno,price))
#输出 李三今年20岁 买了个华为手机3000元 每个月花费49.95元

通过索引号来确保参数放置在正确的位置

quantity=20
itemno=3000
price=49.95
myorder='李三今年{2}岁 买了个华为手机{0}元 每个月花费{1}元'
print(myorder.format(quantity,itemno,price))
#输出李三今年49.95岁 买了个华为手机20元 每个月花费3000元

接下来我们开始六周的学习 一、使用格式化进输出

age=10
print('我今年%d岁'%age)

优点：简化输出 二、 python数据类型 python程序中,为了更充分的利用内存空间以及更有效额管理内存，变量是有不同的数据类型：

python3中6个标准的数据类型：

1.Number(数字,也可以叫它整形) 2.String(字符串) 3.list(列表)

可以存储不用类型的多个值

4.Tuple(元祖)

存储不同类型的多个元素值
语法格式:('元素','元素2'......)
存储的值是不能修改的(程序运行时候)
后期基本没有变化数据

5.Dictionary(字典)

字典也能存储不同类型多个值 
语法格式:{key:value,key2:value2}
一般使用字典存储单个学生信息,最终再把所有学生信息添加列表
定义一个列表接受存储所有学生信息
stu_list = []
定义字典存储单个学生信息
stu = {'name':'张三','age':16,'sex':'男'}
stu2 = {'name':'李四','age':18,'sex':'女'}
扩展：
往列表里面添加元素append
stu_list.append(stu)
stu_list.append(stu2)
print(stu_list)

6.Sets(集合)

里面可以存储不用类型的多个元素值
一般元素值就是列表,字典,元祖
两种创建方式:set()函数
{}创建

还有一个特殊的数据类型，None(空值) 三、 条件控制语句 if语句的基本格式

作用：if语句用来进行判断

if的基本格式
if 要判断的条件：
条件成立，要做的事

if…else 格式：

if 条件:
满足条件，做事情1
满足条件，做事情2
满足条件，做事情3
…
else:
不满足条件，做事情1
不满足条件，做事情2
不满足条件，做事情3

练习：要求，从键盘获取自己的年龄，判断是否大于等于18，如果条件成立输出成年了,反之,未成年

age=input('请输入你的年龄：')
age = int(age)
if age >=18:
    print('成年了')
else :
    pirnt('未成年')

elif

格式：
elif 的使用格式：
if 条件1:
事情1
elif 条件2：
事情2
elif 条件3：
事情3
else: #执行条件为假的结果
要做的事情

说明：当条件1满足时，执行事情1，然后整个if语句结束，当条件1不满足，那么需要判断条件2，如果条件2满足，执行事情2，然后整个if语句结束，当条件1和2都不满足，如果条件3满足，执行事情3，然后整个if语句结束，如果以上条件都不满足,最终执行else条件为假的结果 if还可以嵌套使用

案例，火车安检,先验票,再检查有没有携带违禁品  如果刀子长度没有超过10cm，允许上火车

四、 循环语句 while基本格式

while(循环的条件): 如果循环条件满足
做事情1，
做事情2，
做事情3

案例1:循环输出1-10的数字

i = 1             #定义了一个变量i,给它初始值1
while(i <= 10):
    print(i)
    i += 1        #等价于i = i + 1

案例2:计算1~100之间偶数的累计和（包含1和100）

j = 1
sum = 0  #定义变量接受最终的累积和
while j < 101:
    if j % 2 == 0:
        sum += j
    j += 1
print(sum)

while… else

逻辑：
在条件语句（判断表达式）为false，执行else中的语句2

while 嵌套

while循环，while里面嵌套一个while

格式：

while 条件1：
条件1满足，做事情1
条件1满足，做事情2
条件1满足，做事情3
…
while 条件2：
条件2满足，做事情1
条件2满足，做事情2
条件2满足，做事情3

案例:打印杨辉三角

i=0
while i <=5:
    j=0
    while j <=i:
        print('*',end=' ')
        j=j+1
    print()
    i +=1

五、 for循环 for循环基本格式

for 临时变量 in 序列:
执行循环对应的结果
else:
执行不满足循环条件的结果

案例1 ：循环一个字符串里面每一个字符

name = 'zhangsan'
for temp in name:
    print(temp)

案例2:循环输出1-10的结果

number = '12345678910'
for b in number:
    print(b)

for t in range(1,11):
    print(t)

for t in [1,2,3,4,5,6,7,8,9,10]:
    print(t)

说明：range 函数说左闭右开 扩展

enumerate()枚举函数,用于将一个可遍历的数据对象(字符串,列表,元祖)组合为一个索引序列,可以同时获取下标和元素值
enumarate(序列,起始下标) 不指定起始下标,默认从0开始,指定下标使用最新的,后面的自动增长

for循环的嵌套 案例:输出5*5的矩形

for i in range(5):
    for j in range(5):
        print('*',end='')
    print()   # 换行

break 终止循环 continue 结束当前循环，进入下一次`循环 python数据类型（第二周）

python3里面包含int/float/bool/complex(复数)

一、 python里面常见的赋值方式有3种 1.交互性赋值方式

a,b,c,d = 1,3.5,Ture,4+3j
print(a,b,c,d)
print(type(a),type(b),type(c),type(d))

2.连续性赋值方式

num = num2 = num3 = 10
print(num,num2,num3)
print(type(num),type(num2),type(num3))
print(id(num),id(num2),id(num3))       #他们地址一样

3.单独赋值方式

a = 5
b = 3.8
c = False
d = 10+5j
print(a,b,c,d)
print(type(a),type(b),type(c),type(d))

除了使用type(变量名)获取变量类型外,还可以通过isinstance(变量名,预测的数据类型)获取变量类型

str2 = 'hello'
li = [1,3,5,7]
print(isinstance(str2,str))
print(isinstance(li,str))

二、 常用数据类型转换

函数             说明
int(x)      将x转换为一个整数
float(x)    将x转换为一个浮点数
complex（real,[,imag]）    创建一个复数
str(x)      将对象x转换为字符串
repr(x)     将对象x转换为表达式字符串 用的不多
tuple(x)    将序列转换为元祖
list(x)     将序列x转换为列表
chr(x)      将一个整数转换为一个字符
unichr(x)   将一个整数转换为unicode字符
ord(x)      将一个字符转换为整数
hex（x）    将一个整数转换为一个十六进制的字符串

注意:表达式是不能直接转换,字符串转换里面不能包含字母和特殊字符 三、 常用的模块 import math

math.fabs()    #求绝对值
math.ceil()    #向上取整
math.floor()   #向下取整
math.pow(i,j)  #i的j次方
math.modf()    #取整数部分和小数部分
math.sin()     #正弦函数

import random

random.random()          #求0-1之间的随机数
range(start,end,step)    #返回一个数字列表
random.randrange(start,end,step)  #返回上例数字列表中随机的一个数
random.randint(0,10)     #随机返回一个整数（0-10）

random 应用实例

li = ['一块手表','一部苹果手机','10000元人民币','摩托车']
print(random.choice(li))   #随机返回一个元素抽奖

li = ['一个水杯','一台电脑','一支笔','一副眼镜','一件风衣']
random.shuffle(li)
print(li)                  #随机打乱元素

str = '0123456789abcdefghijklmnopqrstuvwxyz'
res = random.sample(str,6)
for r in res:
    print(r,end='')       #生成6位数的随机验证码

三、字符串 1.字符串的格式

name='yebing'
num = '123123123'
...

注意：字符串里的值不可改 2.字符串的输出

注意：print(‘今天我很开心’,end=’ ') 可以在输出完之后换行

格式化输出

name = '张三丰'
age = 20
price = 100.5
print('我的姓名是:%s,我的年龄是:%d,我有%f人民币'%(name,age,price))

3.字符串的输入 input()函数可以获取键盘输入的信息,返回的结果当做字符串处理，需要存储到一个变量里面

name=input('请输入你的名字')
print(name,type(name))

4.下标 变量名[下标]获取元素值，下标起始值是0，然后递增

name-'zhangsan'
print(name[0])
print(name[1])
...

使用循坏找到在字符串中想要的字母

name ='wangzixuan'
for temp in name:
    if temp = 'x'
    break
print(temp)

5.切片 格式:[开始:结束:步长]

name='wangzixuan'
print(name[::])   #所有的元素
print(name[3::])  #从下标3开始后面的所有元素
print(:3:2)       #从第一个开始间隔为2到第三个

要想从后往前切 最后一个元素下标是-1

name='wangzixuan'
print(name[::-2])  #从后往前输出
print(name[:-2:])  #照样是从前往后输出

6.字符串中的转义字符 定义：将一些普通的字符转换为具有特殊含义的字符-----》转义字符

1.n换行
print('hello nworld')

2.\反斜杠符号
print('hello\123')

3.'单引号
print('he'll'o')

4."双引号
print("hell"owor"ld")

5.t 制表符,相当于一个空格
print('hellotworld')

6.如果转义的字符非常多 可以使用r,表示默认不转义
print(r'anb'ct\d')

7.字符串常见操作 假设有一字符串 mystr=‘hello world’ find:检查str是否在mystr中，如果是返回开始元素的索引，否则返回-1

mystr.find(str,start,end)

index:跟find方法一样，只不过如果str不在myStr中，或直接报错

mystr.index(str,start,end)

count:统计str在字符串中出现的次数

mystr.count(str,start,end)

replace:把myStr中str1(旧元素)替换为str2(新元素)，如果指定了count，则替换不超过count次

mystr.replace(str1,str2,count)

spilt:分割，以str为分隔符切片myStr,返回的是列表（分割后的每一个元素作为列表中的元素（String）

myStr.split("",maxsplit)

capitalize:把字符串中的第一个大写

mystr.capitilize()

title:把字符串中的每一个单词的首字母大写

mystr.title()

swapcase:转换字符串中字母的大小写，小变大，大变小

mystr.swapcase()

startswith: 检查字符串是否以object开头，如果是返回True，反之返回False

myStr.startswith(obj)

endswith:检查字符串是否以object结尾，如果是返回True，反之返回Flase

myStr.endswith(obj)

lower:转换myStr中所有大写字符为小写

myStr.lower()

upper:转换myStr中所有小写字符为大写

myStr.upper() 

ljust:返回一个原字符串左对齐，使用空格填充长度width,形成一个新的字符串

myStr.ljust(width)  #width:表示字符串的长度
注意：如果长度没有原始的字符串的长度长，默认使用字符串的长度

rjust：返回一个原字符串右对齐，使用空格填充长度width, 形成一个新的字符串

myStr.rjust(width)

center:返回一个原字符串居中，使用空格填充长度width, 形成一个新的字符串

myStr.center(width)

lstrip:删除myStr左边的空白字符

myStr.lstrip()

rstrip:删除myStr右边的空白字符

myStr.rstrip()

strip:删除myStr两端的空白字符

mystr.strip()

rfind:类似与find函数,从右边开始查找,如果找到返回元素的开始索引,反之返回-1

myStr,rfind(str,start,end)

rindex:类似与index(),从右往左找,如果找到返回该元素的开始索引,反之直接报错

myStr.rindex(str,start,end)

splitlines：按照行进行分割,返回一个包含每行作为元素的列表

myStr = "hello nworld npython npython"
print(myStr.splitlines())

isalpha：如果myStr所有的字符都是字母,返回True,反之返回False

myStr.isalpha()

isdigit：如果myStr所有的字符都是数字,返回True,反之返回False

myStr.isdigit()

isalnum：如果myStr中所有的字符是字母或者数字,返回True,返回false

myStr.isalnum()

isspace：如果myStr中只包含空格,返回True,返回False

myStr.isspace()

join:myStr中每一个字符后面都会插入str,构造出一个新的字符串(不包含最后一个)

str = '-'
list = ['a','b','c']
print(str.join(list))

eval:函数用来执行一个字符串表达式，并返回表达式的值

eval(str)   
print(eval('12+3'))
print(eval('12-3'))

len:返回字符串的长度

len(str)

chr:函数使用一个范围range(256)内(0~255)整数作为参数,返回对应的字符ACSII码

chr(0~255)

unichr:unichr和chr一样,区别在于unichr返回的是unicode(将整数返回成unicode字符) 四、列表 可以存储不同类型的多个数据 比如存放班级里面所有学生的名字 1.列表格式：列表名 = [列表选项1,列表选项2,…,列表选项n] 特点：列表中元素可以是不同类型的

nameList = ["xiaoming","xiaowang"，1,True,3.14,4+3j,None]

2.列表下标 列表同样也支持下标索引，与字符串相同从0开始

nameList = ["xiaoming","xiaowang","xiaoliu"]
print(nameList[0])
print(nameList[1])
print(nameList[2])

通常用这种方法太麻烦，我们都用循环

for n in nameList:
    print(n)

i=0
while i < len(nameList):
    print(nameList[i])
    i+=1

3.列表中常见的操作（非函数） 假设有一列表list=[1,2,3,4,5] 列表元素的访问

print(list[1])

列表元素的替换

list[1]=100

列表的组合

list2=[6,7,8,9]
lst=list+list2
print(lst)

列表的重复

list=list*3
print(list)

in判断元素是否在列表中,如果找到返回True,反之False

if 10 in list:
    print('True')
else:
    print('False')

截取 （包左不包右）

print(list[0:3])

4.列表中常见的操作 （函数） 4.1 添加元素 通过append函数可以向列表中添加元素

nameList = ["xiaoming","xiaowang","xiaoli"] 
nameList.append('xiaoqiang')
print(nameList)

extend:通过该函数可以向列表中添加元素

a = [1,2]
b = [3,4]
a.extend(b)
print(a)        #这样输出是[1,2,3,4]
倘若是用append   则输出[1,2,[3,4]]

insert(index,object):在指定的位置index前插入元素object

nameList.insert(1,'xiaoyao')
print(nameList)

4.2 修改元素 修改元素的时候，要通过下标来确定需要进行的修改的元素，然后才能进行修改

a = [1,2,3,True,"hello"]
a[0] = 'daming'
print(a)

4.3 查找元素（in/not in/index/count） in(存在):如果存在返回的结果为True,反之False not in(不存在):如果不存在结果为True,反之False

name = input('请输入你要查找的姓名:')
if name in nameList:
    print('存在')
else:
    print('不存在')

print(nameList.index('xiaoli'))

print(nameList.count('xiaoli'))

4.4 删除元素 删除元素（del/pop/remove） del:根据下标进行删除

international = ['中国','韩国','日本','美国']
del international[2]

pop:删除最后一个元素

international.pop()

remove:根据元素的值进行删除

international.remove('日本')

4.5 排序 sort：将列表按照特定的顺序重新的排列，默认由小到大

li = [9,100,78,0,111,-3]
print(li)
li.sort()
print('排序之后结果:')
print(li)

reverse:逆序

li.reverse()
print('逆序之后的结果是:')
print(li)

4.6其他一些常见函数

len:求列表长度
max: 列表中最大值
min:列表中最小值

5.列表的嵌套 格式：列表名 = [[],[],[]]

schoolNames = [["清华大学"，"北京大学"],["工程大",'立信'],['合肥汽修院校']]

例子：一个学校，有3个办公室，现在有8个老师等待分配工位，请编写程序，完成随机分配

#定义一个嵌套列表存储学校里面3个办公室
offices = [[],[],[]]
#定义一个列表存储8位老师的名字
nameList = ['张学友','刘德华','黎明','郭富城','王菲','张柏芝','张韶涵','杨颖']
import random
#循环获取每个老师的名字
for name in nameList:
#使用随机数产生3个办公室
index = random.randint(0,2)
#offices[0] offices[1] offiices[2]
offices[index].append(name)
print(offices)
i = 1  #办公室编号
for tempNames in offices:
print('办公室%d的人数是%d'%(i,len(tempNames)))
i += 1
for name in tempNames:
print('老师的名字是%s'%name)

五、元组

python的元祖和列表类似，不同之处在于元祖的元素不能修改，比如身份证号

1.格式

元祖名 = (元祖元素1，元祖元素2.....元祖元素n)
是一个有序的集合

2.元组中常见操作 2.1创建空的元组

tuple = ()

2.2定义元祖的时候只定义一个元素

tuple = (1,)  
如果单单是tuple=(1)  那么tuple的值就是1 是int类型

2.3元祖的删除

del tuple

2.4元组的组合

tuple1+tuple2

2.5判断元素是否在元组中

a=(1,2,3,4)
if 1 in a:
    print('true')
else:
    print('false')

2.6元组的截取

print(tuple[0:3])

3.元组的嵌套 元组的元素是元组

tuple5 = ((1,3,5),(2,4,6))
print(tuple5[0][2])
for temp in tuple5:
   for t in temp:
       print(t,end='')

六、字典 1.字典的格式

{key:value,key:value....}
例如：info = {"name":"周杰伦","age":30,"address":"北京"}

字典中的每一个元素分为两个部分，前面是键 后面是值

例如：
name ---------> key
周杰伦 ---------> value

2.根据键找值 可以通过key 找到相应的 value

stu_info = {'name':'张三丰','age':30,'no':110}
print(stu_info['name']  # 会得到张三丰

3.get函数 在我们不确定字典中是否存在某一个键而又想获取它的值，可以使用get(),可以设置默认值

stu_info = {'name':'张三丰','age':30,'no':110}
res=stu_info.get('address','上海市')
print(res)  #会得到上海

4.字典的常见操作 4.1 修改元素

stu_info = {'no':110,'name':'张三','age':20}
stu_info['age'] = 18  # 这样就修改成功咯

4.2 添加元素

stu_info['mobile'] = 13248301214 

与修改元素相同，该键字典中如果不存在的话，会自动创建 4.3 删除元素 4.3.1 del :删除指定的元素

del stu_info['age']  #删除字典中指定某个元素
del stu_info   #删除字典所有元素  相当于内存里面删除

4.3.2 clear : 清空字典中元素，返回空字典

stu_info.clear()

5.字典中常用的函数

len():测量字典中,键值对的个数
print(len(stu_info))

keys():返回一个包含字典中所有key的列表
print(stu_info.keys())

values():返回一个包含字典中所有值value的列表
print(stu_info.values())

items():返回一个包含所有(键   值)元祖的列表
print(stu_info.items())

6.字典的遍历 假设有一字典 dict = {‘name’:‘张三’,‘age’:20,‘address’:‘上海市’,‘no’:110} 6.1获得字典中所有key

allkeys = dict.keys()
for temp in allkeys:
    print(temp,end=' ')

6.2获得字典中所有value

allValues = dict.values()
print(allValues)
for temp in allValues:
    print(temp,end=' ')

6.3获得字典中key value 键对

items = dict.items()
print(items)
for key,value in items:
    print(key,value)

7.字典和列表优缺点

字典和列表比较：
1.查找和插入的速度较快，不会随着key-value的增加而变慢
2.需要占用较大的内存

列表占用空间小

七、集合

集合与之前的列表和元祖类似，可以存储多种类型数据，这些数据不能重复
可以使用大括号 { } 或者 set()函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

1.格式

parame = {value1,value2...}
或者
set = set(value,value2...)

其只有value,没有key，且是无序的

开发场景:去除重复的数据 2.集合中常见的操作 2.1添加 add

set = set([1,2,3,4]) #集合的元素不能是数字
set=set(1,2,3,4)  不行！
set.add(5)
print(set)  会得到{1，2，3，4，5}
set.add((5,6))  会得到{1，2，3，4，（5，6）}

2.2update()可以插入list/tuple/String

set.update([5,6])
set.update((7,8))
set.update({9:'hello',10:'world'})
set.update('0')
print(set)
#会得到 {1,2,3,4,5,6,(7,8),9,10,'0'}

2.3 删除

set.clear()

2.4 遍历

for i in set:
    print(i,end='')

2.5交集/差集/并集 开发场景:好友之间的共同爱好 交集 &

s = set([1,2,3,4])
s2 = set([3,4,5,6])
print(s & s2)
print(s.intersection(s2))

并集 |

print(s | s2)
print(s.union(s2))

差集 -

print(s - s2)
print(s.difference(s2))

差集 对称差集

print(s.symmetric_difference(s2))

八、生成器

比如有一个列表 列表有什么特点 一个有序的集合
首先列表容量是有限的,比如定义一个列表存储一百万条数据

实际上我只使用列表前几条数据 后面大量数据都用不到 浪费大量资源

优点:
生成器当我们使用列表数据才会使用内存 或者不会占用内存 节省资源

1.生成器的创建

generator = (x*2 for x in range(5))
print(next(generator))  #输出0
print(next(generator))  #输出2 
...

或使用循环
for temp in generator:
    print(temp)

2.yleld关键字

def flib3():
a = 0
b,c = 0,1 #交互性赋值方式
while a < 5:
    yield c
    b,c = c,b+c
    a += 1
res = flib3()
print(res)
print(next(res))   #1
print(next(res))   #1
print(next(res))   #2  运用了生成器

九、迭代器 1.概念

迭代：比如搭建房子一层层盖
访问集合元素的一种方式
迭代对象：
是一个可以记住遍历位置的对象(上楼梯)
迭代器对象从集合的第一个元素开始访问，直到所有的元素访问完毕为止

迭代器的特点：
只能往前，不会后退

2.迭代对象

直接作用与for循环，for循环的数据类型有哪些？
一类：str list tuple dict set
二类：生成器

这些可以直接作用与for循环的对象的统称----》迭代对象 ： Iterable

3.isinstance

####可以用isinstance 来判断对象是否可迭代
from collections import Iterable
a = isinstance([],Iterable)

4 迭代器的使用

定义：可以被next()函数调用并且不断的返回下一个值的对象----》迭代器 Iterator

5 iter()函数

生成器都是Iterator对象，但是list dict str 都是迭代对象但是不是迭代器,可以通过iter函数转换