第一章 python入门

#编码
中文编码有万国码（Unicode）、utf8、GBK
其中utf8中文占三个字节，GBK中文占两个字节，一个字节等于八位
其中utf8可以跟Unicode相互转化
GBK可以转变成unicode Unicode做中文处理的时候可以与GBK转化

1.变量必须由字母数字下划线组成
2.数字不能作为开头
3.不能是python中的关键字，最好不要跟python中内置的东西重复

注意：1.=比较的是vlaue
     2.is 比较的是id



强调：1.id相同，意味着type跟value必定相同
     2.value相同type不也相同，id可能不相同：
          x='juxianwen'
          y='juxianwen'
          id(x)
          4376607152
          id(y)
          4376607408
          x==y
          True
          x is y
          False

#1.在交互模式下
python实现int的时候由小数池。为了避免因为创建相同的值而重复申请内存空间所带来的效率问题，python解释器会再启动时创建出小数池，
范围是[-5,256]，在该范围内的整数对象是全局解释器范围内被重复使用，永远不会被回收。（也就是说创建出来这个范围内相同的数字的id
相同）


#在pycharm中
在pycharm中会过大这个范围

常量是指不变的量，程序员约定俗成的用变量名全大写表示常量

#ps 在c语言中有专门的常量定义语法，const、int、count，一旦定义为常量，更改便会报错

#在python3中
input：用户输入的任何值，都存成字符串类型



#在python2中
input：用户输入什么类型，就存什么类型
raw_input:等于python3的input

1 name=input('请输入用户名：')
2 pass_world=input('请输入用户密码：')
3 if name=='root' and pass_world=='root':
4     print('登录成功')
5 else:
6     print('登录失败')

#1  不用全部都加注释，只是把自己觉得难理解的地方加上注释
 2. 注释可以用中文也可以用英文但是不要用拼音
 3.单行注释用# 多行注释用三对双引号"""  """

#int 整型
定义：age=10  #age=int(10)
功能：用于标识 工资 身高 体重

#int整形了解部分
在32位机器上，整型的位数为32位，取值范围为 -2**32~2**32-1
在64位系统上，整型的位数为64位，取值范围为-2**63~2**63-1



#long长整型
跟c语言不同，python的长整型没有指定位宽，即：python没有限制长整型的数值大小，但由于机器内存有限制所有我们使用的长整型不能
无限大。

注意在python2.2以后，如果整型发生溢出，那么python自动将整数数据转化为长整数，所以现在长整数数据后面不加字母L也不会产生严重
后果。


注意自python3以后不再有长整型，全部是int

整型的功能
1.如何将其他形式转化为整型：
  若a='123'
  b=int(a) 这样子b=123 b就变成了一个整型

  num='0011'

#在python中，加了引号的字符就是字符串类型，python并没有字符类型。
定义：name='jxw' 相当于name=str(jxw)
用于标识：描述性内容，如姓名、性别等
len,join,for,索引切片 在别的数据结构中也能用

#那么单引号、双引号、多引号有什么区别呢？
单双引号没有什么区别，只有在下面这种情况你需要考虑单双号的配合。
msg=" I'am A"


多引号用于进行多行注释。

#字符串的加减
name='jxw'
age='18'
name+age  输出的是  jxw18 类型是字符串
name*5    输出的是 jxwjxwjxwjxwjxw 类型是字符串

注意1：字符串相加的效率不高
字符串1+字符串2，并不会在字符串1的基础上加上字符串2，而是申请一个全新的内存空间，存放字符串1和字符串2，所以占用了内存。
注意2：只能字符串加字符串，不能字符串加其他类型

#字符串的功能
1.字符串首字母大写
  text='alex'
  v=test.capitalize()
  print(v)  输出的是Alex
2.大写变成小写
  test.casefold() 这条命令是不管什么国家的语言都可以变成小写
  test.lower() 这个是只能英文字符大写转化为小写
3.填补功能
  test='alex'
  v=test.ceter(20)
  print(v)
  输出的是        alex       空格加alex总共为20位
  v=test.cete(20,'*')
  print(v)
  输出的是********alex********
4.计算字符串中某个字符的个数
  test='alexalex'
  v=test.count('e')
  计算e在alexalex中出现多少次
  v=test.count('ex',1,6)从第二个位置到第七个位置ex出现了多少次，但是不包括第二个位置跟第七个位置
5.判断以什么结尾，以什么开头
 test='alex'
 test.endwith('a',1,3)  看alex 在它的第二个位置到第四个位置是不是以a结尾的（包括第四个位置）
 test.startwith('a') 看alex是否以a开头
6.寻找目标所在位：
 test='alexalex'
 v=test.find('ex',1,4) 在第二个位置跟第五个位置寻找ex在哪个位置（不包括第五个位置），寻找到第一个ex就不往后找了
7.将字符串中的占位符替换成指定的值
test='I am {name},age{a}'
test.format(name='alex',a=19) 输出I am alex，age19

相当于test='I am {name},age{name}'.format(**{name:'alex',age:19})字典形式得加**

test='I am {0},age{1}'test.format('alex',19)   输出I am alex，age19  按照顺序来的先0后1

test='I am {name}'.format('name'='xa')
test.format_map({'name':'alex'})输出的是 I am alex 
test='{0},{0}'.format(1,2,3)输出的是11
test='i am {0[1]}'.format([1,2,3],[123])输出的[1,2,3]中的第二个元素 即 i am 2
test='{:s} {:d} {:f}'.format('sex',1,1.2) :s接受字符串 :d接受数字 :f接受浮点数 输出的是 sex 1 1.2
test='{:s} {:d}'.format(*['sex',12])  *['sex',12]是指的是输入整个列表 输出的是 sex 12

test='{:b}(输入二进制) {:o}(输入八进制) {:d}(输入整型) {:x}（16进制 输入小写abcd） {：X}（输入16进制 输入大写ABCD）
      {.%}(显示百分比默认显示小数点6位)'.format(15,1,15,15,15,15,8,2)
      


8.寻找字节在哪个位置

9.判断字符串是否只包含字母与数字
test.isalnum 是的话是True不是的话Flase
10.断句换行功能
expandtabs（a）在a个字符之内遇到\t直接用空格填充到6
比如：s='uba\tk'
     a=s.expandtabs(6)输出的是uba  k总共位
断句，先将前6个拿出来无tab忽略再找6个，找到\t后补充到6个
11.判断是否全为字母跟汉字
text.isalpha（） 全是输出True 反之输出Flase
12.判断是否全为数字
test.isdecimal() 这个甚至可以判断特殊的数字比如① 二
test.isdigit()只能判断普通的数字
12.判断是否为标识符 
标识符=有字母数字下划线组成（字母不开头）
test.isidentifier()是的话TRUE反之Flase
13.islower（）判断是否为小写
14.判断是否可以打印
什么叫做可打印：如果存在\t,\n这些不可现实的字符就是不可打印
test.isprintable() 可打印true反之false
15.判断是否全为空格
test.isspace（）判断是否全为空格
16.判断是否为标题
什么是标题：所有单词的首字母大写就是标题
test.istitle()
17.将字符串中的每个元素按照指定分隔符进行拼接
join(self,iterable)
test='你是风儿，我是沙'
t=' '
v=t.join(test) 输出 你 是 风 儿 ， 我 是 沙
18.填充字符

右填充 ljust
v='alex'
a=v.ljust(5,'*') 输出的是*alex
左填充
v='alex'
a=v.rjust(5,'*')输出的是alex*
左填充0（只能填充0）
v='alex'
a=v.zfill(5)输出的是0alex
19.判断字符串是否全为大写
test.isupper()
20.消除指定字符串
消除空格
test.strip()消除两边空格
test.lstrip()消除左边空格
test.rstrip()消除右边空格
\n \t 也可以消除 
test='\nalex'
v=test.lstrip()这样输出的也是alex
消除指定的元素
test='xalex'
v=text.lstrip('x')  输出的是alex
21.转变字符串的特定内容
test='你是风儿我是沙'
text1='去你妈的风和沙'
v='你是风儿我是沙，缠缠绵绵去你家'
将v中test内容换成test1中的内容
m=v.maketrans('你是风儿我是沙'，'去你妈的风和沙')
new_v=tanslate（m）
22.分割
test='testastsd'
test.partition('s') 输出的是 'te','s','tastsd' 只分割第一个s
test.rpartition('s')从右起第一个s作为分割 'testast','s','d'
test.split('s') 'te','ta','t','d'
可以指定分割次数test.split('s',1)输出的是'te','tastsd'
从右开始分割 test.rsplit('s')
22.根据换行符进行分割
test='a\na\n'
v=test.splitlines()输出的['a','a']
v=test.splitlines(True)输出的是['a\n','a\n']
v=test.splitline(Flase)输出的是['a','a']
23.大小写转换
test='alex'
v=test.swapcase() 输出的是ALEX 
24.字符串的索引，切片，长度功能
test='alex'
索引 test[0] 输出的是a
切片 test[0:1] 输出范围 0=<x<1 
    test[0:-1]输出的范围是第一位到最后一位
长度 test='你是猪'
    len(test)在python3中输出的是三，在python2中输出的是9 因为utf8中一个汉字占三位
    li=['2','1','0']
    len(li)输出的是三
for zjw in test:
    print(zjw)
相当于：
index=0
while index <len(test):
    v=test[index]
    print(v)
    index=index+1
25.替换
test='alexalexalex'
test.replace('ex','bbb')输出的是albbbalexalex
test.replace('ex','bbb',2)输出的是albbbalbbbalex
26.创建连续的数字
v=range(100)
print(v) 输出的是range(100)
for i in v:
     print(i) 输出的是0到99
也可以设置步长
v=range(0,100,5)
for i in v:
    print(i)输出的是0 5 10 。。。。

#习题 将 文件索引打印出来
test=input('')#需要打印索引的内容
l=len(test)
r=range(0,l)
for k in r:
    print(k,test[k])

#在[]内用逗号分隔，可以存放n个任意类型的值 
定义：students=['1','2','3']
#students=list(['1','2','3'])
用于标识：存储多个值得情况，比如一个人的多个爱好

#存放多个学生的信息：姓名，年龄，爱好
student_info=[['egon',18,['play']],['alex',18,['play','sleep']]]
student_info[0][2],[0] 输出的是play
列表可以有索引、切片
列表可以进行for，while 自然也支持break contiune

链表：因为列表存储不是连续存的，就是在第一个位置里存放着第二个位置的坐标。正因为列表存储不连续，所以列表可以修改
     比如：列表第一个位置为20
          li[0]=120 第一个位置就由20变成120

1.删除，修改功能
del li[1] 将li的第二个位置删除掉
del li[2:6]删除li的 3,4,5,6位置的元素
li[1:3]=[120,90]第二位换成120，第三位换成90
2.列表中是否有这个元素
v=12 in li
print(v)如果12在li中输出的True 如果不在输出Flase
3.取列表的特定的值
li=[1,12,9,8,['1',['19',10]],'alex',True]
li[4][1][0] 输出的是19
4.字符串转化为列表的原理
s='1234'
list(s)
这个原理是
list=[]
for i in s:
    list=list.append(i)
li=[1,2,3]
str(li）输出的是'[1,2,3]'
5.末端插入
li=[1,2,3]
li.append(5)
print(li)输出的是[1,2,3,5]
5.清空列表
li.clear()
6.浅拷贝
li.copy
7.计算列表中元素出现了多少次
v=li.count(22)看列表li中22出现了多少次
8.扩展列表，参数为可迭代对象
li=[11,22,33,44,55]
li=extend([98,12])
print(li)  输出的是[11,22,33,44,55,98,12]
9.从左往右找值，找到第一个就不继续找下去了
li=[11,22,33,44,55]
v=li.index(22) #index(x,start,end)
10.在指定位置插入一个值
li=[11,22,33]
li.insert(0,99)
print(li)输出的是[99,11,22,33]
11.删除指定位置元素，并且可以获取到这个元素
li=[1,2,3]
v=li.pop()
print(v)输出的是3
v=li.pop(1)删除第二个位置的元素,并获取这个值赋值给v
12.删除指定元素
li.remove(22)删除从左到右第一个22
13.将列表进行翻转
li=[1,2,3]
li.reverse()
print(li)输出的是[3,2,1]
14.进行排列
li=[11,44,22,33,22]
li.sort
print(li) 输出的是[11,22,22,33,44]
li.sort(reverse=True)
print(li)输出的是[44,33,22,22,11]

#练习题
1.l=[1,2,3,4,5,6]
  正向步长：l[0:3:1] 输出的是[1,2,3]
  反向步长：l[2：：-1]输出的是[3,2,1]
  列表翻转：l[::-1]输出的是[6,5,4,3,2,1]
2.用列表data=['alex',49,[1900,3,18]],分别取出列表中名字，年龄，出生的年，月，日赋值给不同的变量
  data[0]输出的是 alex
  data[1]输出的是 49
  data[2]输出的是 [1900,3,18]

列表：有序、[]、可以增删
元组：li=（1,2）小括号，可以查看li[0]（这里就已经证明元组是有序的）,li[0:6]，但是不可以修改跟删除,可迭代 for i in li： 
因为可以迭代所以 元组列表
     字符串可以相互转化。注意：元组的一级元素不可修改、删除、增加，但是二级元素确不一定不可以修改。
元组的join可以用
tu=（'asdf','asdf'）
v='_'join(tu)输出的是asdf_asdf
count计数
index获取指定元素在元组中的索引

字典的作用：可以存放多个任意类型的值，并且可以硬性规定值得映射关系。

#在{}内用逗号分隔，可以存放多个key，value的值，其中value可以是任意值，key只能是数字、字符串、布尔值，每一个值都有唯一一个
key对应，可以更为高效方便的取值。
注意：key重复时只能保留一个
     布尔值作为key时，True相当1，所以数字1跟True同时存在的时候只保留一个。False相当于数字0.

info={
     'name':'se',
     'hobbies':['play','sleep'],
     'company_info':{
          'name':'oldboy',
          'type':'edu'
          'emp_num':40
     }
  
}
print(info['company_info']['name']} 输出的是 oldboy
del infor('name') name:se 这个键值对就被删除了

注意：字典不可以被while循环，但是可以进行for循环。
for i in infor:  相当于 for i in infor.keys(): 默认输出的是key
for i in infor.values():  这个是只循环初values
for i,v in infor.items(): 这个是将key value 都循环出来。
v='v1' in dic.values() 判断v1在没在value中出现

字典的功能：

1.clear清空功能

2.copy复制功能

3.fromkeys（直接写类名）根据序列创建字典，并指定统一值。

v=dict.fromkeys(['k1',123,'99'])
print（v)输出的是{123:None,'k1':None,'999':None}
4.字典的取值功能


v=dic.get('k1')取到k1这个键对应的值，如果没有输出None



v=dic.get('k11',111)输出k11键对应的那个值，如果没有输出111

5.字典的删除功能
v=dic.pop('k1')删除k1对应的那对键值对
print(k1)输出k1那个键对应的那个值

v=dic.pop('k1',111)
print(v)如果字典中本来没有k1 这样就输出111
6.设置默认值
v=dic.setdefault('k1','123')如果k1存在则k1不设置成123，print(k1)将输出字典中的k1
如果k1不存在，那么将k1作为键123作为值放入字典中，print（dic['k1']）输出的是123
7.更新
dic.update({'k1':'1111','k2'=123}) 相当于 dic.(k1='1111',k2=123)
如果dic中k1已经存在，那么久覆盖掉，如果不存在更新上。

#布尔值 一个True 一个False
bool（a）将a转化为布尔值
#所有类型都自带布尔值
1.None，0，空 都为False
2.其余值都为True

#可变类型：在id不变的情况下，value可变，则称为可变类型，如列表、字典。
#不可变类型：value一旦改变，id也得变，则成为不可变类型（id变，意味着创立新的内存空间）

#作用：去重、关系运算
#集合的定义：
   1.集合可以包括多个元素，用逗号分割开
   2.每个元素必须是不可变类型（可hash，可作为字典key）
   3.没有重复元素
   4.无序
例：s=set('hello')
   print(s)输出的是{'h','e','l','o'}
   
   s=set(['alex','alex','sb'])
   print(s)输出的是{'alex','sb'}

#集合的功能
1.添加元素
s={1,2,3}
s.add('s')
print(s)输出的是{1,2,3，s}
2.清空功能
s.clear()
print(s) 输出的是set（）
3.复制功能
s1=s.copy()
这个我相当于s1==s
4.删除功能
v=s.pop()这个是随机删除
v=s.remove(1)指定删除元素1，如果没有1，则会报错
v=s.discard（1）指定删除元素1，如果没有1也不会报错
5.交集
python_1=['lv','gh','gg']
linux_1=['lv','cnm','nmb']
python_and_linux=[]
for i in python_1:
    if i in linux_1:
        python_and_linux.append(i)
python_and_linux=set(python_and_linux)    
这段程序相当于 p_s=set(python_1)
            l_s=set(linus_1)
            print(p_s.intersection(l_s)) 相当于 print(p_s&l_s)
6.并集
print(p_s.union(l_s)) 相当于 print(p_s|l_s)
7.差集：p_s中减去P_s与l_s的交集
print(p_s.different(l_s))相当于print(p_s-l_s)
进行差集以后，p_s与l_s并没有改变
p_s=p_s-l_s 相当于 p_s.different.updata(l_S)  p_s就更新为 p_s-l_s
8.交叉补集：p_s并上l_s在减去p_s交上l_s
print(p_s.symmetric_difference(l_s)) 相当于 print(p_s^l_s)
9.判断s1，s2集合是否为空
print(s1.isdisjoint(s2))若是为空则输出True
10.子集，复集   若s1为s2的子集，那么s2为s1的复集
子集：print(s1.issubset(s2))如果是子集输出True
复集 ：print(s2.issuperset(s1))如果 s2>=s1那么输出True
11.不可变集合：
s=forzenset('hello')
通过这个命令形成的集合不可增加也不可删除

有如下列表
l=[
{'name':'alex','age' :18,'sex'='male'}

{'name':'egon','age' :73,'sex'='male'}

{'name':'alex','age' :20,'sex'='female'}

{'name':'alex','age' :18,'sex'='male'}

{'name':'alex','age' :18,'sex'='male'}

],去重，得到新列表并且保留原来顺序。

a=[{'name': 'egon', 'age': 18, 'sex': 'male'},
    {'name': 'alex', 'age': 73, 'sex': 'male'},
    {'name': 'egon', 'age': 18, 'sex': 'female'},

    {'name': 'egon', 'age': 18, 'sex': 'male'},
    {'name': 'egon', 'age': 18, 'sex': 'male'},

   ]
b=[]


num=len(a)



while num>0:

    num=num-1
    v=a.pop()


    for i in a:
        if i['name']==v['name'] and i['age']==v['age'] and i['sex']==v['sex']:
            a.remove(i)#当a发生改变时直接跳出for 循环
    a.append(v)

print(a)

数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

#三者的优先级从高到低分别是：not，or，and
>>> 3>4 and 4>3 or 1==3 and 'x' == 'x' or 3 >3
False
#最好使用括号来区别优先级，其实意义与上面的一样
>>> (3>4 and 4>3) or ((1==3 and 'x' == 'x') or 3 >3)
False 

#is比较的是id
#而==比较的是值

# 如果:今天是Monday,那么:上班
# 如果:今天是Tuesday,那么:上班
# 如果:今天是Wednesday,那么:上班
# 如果:今天是Thursday,那么:上班
# 如果:今天是Friday,那么:上班
# 如果:今天是Saturday,那么:出去浪
# 如果:今天是Sunday,那么:出去浪


#方式一：
today=input('>>: ')
if today == 'Monday':
    print('上班')
elif today == 'Tuesday':
    print('上班')
elif today == 'Wednesday':
    print('上班')
elif today == 'Thursday':
    print('上班')
elif today == 'Friday':
    print('上班')
elif today == 'Saturday':
    print('出去浪')
elif today == 'Sunday':
    print('出去浪')
else:
    print('''必须输入其中一种:
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
    Sunday
    ''')

#方式二：
today=input('>>: ')
if today == 'Saturday' or today == 'Sunday':
    print('出去浪')

elif today == 'Monday' or today == 'Tuesday' or today == 'Wednesday' \
    or today == 'Thursday' or today == 'Friday':
    print('上班')

else:
    print('''必须输入其中一种:
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
    Sunday
    ''')


#方式三：
today=input('>>: ')
if today in ['Saturday','Sunday']:
    print('出去浪')
elif today in ['Monday','Tuesday','Wednesday','Thursday','Friday']:
    print('上班')
else:
    print('''必须输入其中一种:
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
    Sunday
    ''')

while 条件:    
    # 循环体
 
    # 如果条件为真，那么循环体则执行，执行完毕后再次循环，重新判断条件。。。
    # 如果条件为假，那么循环体不执行,循环终止

#打印0-10
count=0
while count <= 10:
    print('loop',count)
    count+=1

#打印0-10之间的偶数
count=0
while count <= 10:
    if count%2 == 0:
        print('loop',count)
    count+=1

#打印0-10之间的奇数
count=0
while count <= 10:
    if count%2 == 1:
        print('loop',count)
    count+=1

import time
num=0
while True:
    print('count',num)
    time.sleep(1)
    num+=1　　 

　tag=True 

　　while tag:

　　　　......

　　　　while tag:

　　　　　　........

　　　　　　while tag:

　　　　　　　　tag=False

#练习，要求如下：
    1 循环验证用户输入的用户名与密码
    2 认证通过后，运行用户重复执行命令
    3 当用户输入命令为quit时，则退出整个程序 

#实现一：
name='egon'
password='123'

while True:
    inp_name=input('用户名: ')
    inp_pwd=input('密码: ')
    if inp_name == name and inp_pwd == password:
        while True:
            cmd=input('>>: ')
            if not cmd:continue
            if cmd == 'quit':
                break
            print('run <%s>' %cmd)
    else:
        print('用户名或密码错误')
        continue
    break

#实现二：使用tag
name='egon'
password='123'

tag=True
while tag:
    inp_name=input('用户名: ')
    inp_pwd=input('密码: ')
    if inp_name == name and inp_pwd == password:
        while tag:
            cmd=input('>>: ')
            if not cmd:continue
            if cmd == 'quit':
                tag=False
                continue
            print('run <%s>' %cmd)
    else:
        print('用户名或密码错误')

break 是直接结束所有循环 continue结束当前循环在会到本层循环重新开始循环
while 1==1：（break直接回到这里并且结束这里）

#与其它语言else 一般只与if 搭配不同，在Python 中还有个while ...else 语句，while 后面的else 作用是指，当while 
循环正常执行完，中间没有被break 中止的话，就会执行else后面的语句
count = 0
while count <= 5 :
    count += 1
    print("Loop",count)

else:
    print("循环正常执行完啦")
print("-----out of while loop ------")
输出
Loop 1
Loop 2
Loop 3
Loop 4
Loop 5
Loop 6
循环正常执行完啦
-----out of while loop ------

#如果执行过程中被break啦，就不会执行else的语句啦
count = 0
while count <= 5 :
    count += 1
    if count == 3:break
    print("Loop",count)

else:
    print("循环正常执行完啦")
print("-----out of while loop ------")
输出

Loop 1
Loop 2
-----out of while loop ------

for i in range（1,9）：
    for t  in range(1,i):
        print(i)
        break
输出的是 2,3,4,5,6,7,8为什么从2开始输出，因为开始i是1所以变成for t in range（1,1）这个自动结束重新进行 for i in range（1,9）就从2开始