##C++
##include <iostream>
 int main(void)
 {
  std::cout<<"Hello world";
 }

##C
##include <stdio.h>
int main(void)
{
printf("\nhello world!");
return 0;
}

##JAVA
public class HelloWorld{
  // 程序的入口
  public static void main(String args[]){
    // 向控制台输出信息
    System.out.println("Hello World!");
  }
}

##PHP
<?php  
             echo "hello world!";  
?>

##Ruby
日本人开发的，砸日本车的时候，顺手就把你拖出去打死了，祭天
 puts "Hello world."

##GO
package main
import "fmt"
func main(){
    fmt.Printf("Hello World!\n God Bless You!");
}

##Python
print("Hello World")

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

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

代码注释的原则：
    #1. 不用全部加注释，只需要在自己觉得重要或不好理解的部分加注释即可
    #2. 注释可以用中文或英文，但不要用拼音
文件头
##!/usr/bin/env python
## -*- coding: utf-8 -*- 

##======================================基本使用======================================
##1、用途
##2、定义方式
##3、常用操作+内置的方法

##======================================该类型总结====================================
存一个值or存多个值
有序or无序
可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

##整型int
　　作用：年纪，等级，身份证号，qq号等整型数字相关
　　定义：
　　　　age=10 #本质age=int(10)

##浮点型float
　　作用：薪资，身高，体重，体质参数等浮点数相关

    salary=3000.3 #本质salary=float(3000.3)

##二进制，十进制，八进制，十六进制 
1.bin()函数将十进制转换成而进制
2.oct()函数将十进制转换成八进制
3.hex()函数将十进制转换成十六进制   

##长整形（了解）
    在python2中（python3中没有长整形的概念）：　　　　　　
    >>> num=2L
    >>> type(num)
    <type 'long'>

##复数（了解）　　
    >>> x=1-2j
    >>> x.real
    1.0
    >>> x.imag
    -2.0　　

##作用：名字，性别，国籍，地址等描述信息
##定义：在单引号\双引号\三引号内，由一串字符组成

while True:
    name=input("name:")
    age=input("age:")
    sex=input("sex:")
    height=input("height:")
    msg='''
             ------------%s info-----------
             name:%s
             age:%s
             sex:%s
             height:%s
             ------------------------------
        '''%(name,name,age,sex,heigth)
    print(msg)

name='allen' #name=str('allen')
print(type(name))

##1.移除空白strip
msg='             hello         '
print(msg)
print(msg.strip())
移除‘*’
msg='***hello*********'
msg=msg.strip('*')
print(msg)
##移除左边的
print(msg.lstrip('*'))
##移除右边的
print(msg.rstrip('*'))
 
##用处
while True:
    name=input('user: ').strip()
    password=input('password: ').strip()
    if name == 'allen' and password == '123':
        print('login successfull')

##切分split
info='root:x:0:0::/root:/bin/bash'
print(info[0]+info[1]+info[2]+info[3])

user_l=info.split(':')
print(user_l[0])

msg='hello world allen say hahah'
print(msg.split()) #默认以空格作为分隔符
 
cmd='download|xhp.mov|3000'
cmd_l=cmd.split('|')
print(cmd_l[1])
print(cmd_l[0])
print(cmd.split('|',1))
 
##用处
while True:
    cmd=input('>>:　').strip()
    if len(cmd) == 0:continue
    cmd_l=cmd.split()
    print('命令是:%s 命令的参数是:%s' %(cmd_l[0],cmd_l[1]))

##长度len
print(len('hell 123'))

##索引
切片:切出子字符串
msg='hello world'
print(msg[1:3]) #1 2
print(msg[1:4]) #1 2 3

##startswith,endswith
name='alex_SB'
print(name.endswith('SB'))
print(name.startswith('alex'))

##replace
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))

print('my name is %s my age is %s my sex is %s' %('allen',18,'male'))
print('my name is {} my age is {} my sex is {}'.format('allen',18,'male'))
print('my name is {0} my age is {1} my sex is {0}:{2}'.format('allen',18,'male'))
print('my name is {name} my age is {age} my sex is {sex}'.format(sex='male',age=18,name='allen'))

name='goee say hello'
print(name.find('S',1,3)) #顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引
print(name.index('S')) #同上,但是找不到会报错
print(name.count('S',1,5)) #顾头不顾尾,如果不指定范围则查找所有

##join
info='root:x:0:0::/root:/bin/bash'
print(info.split(':'))

l=['root', 'x', '0', '0', '', '/root', '/bin/bash']
print(':'.join(l))

##lower,upper
name='eGon'
print(name.lower())
print(name.upper())

##expandtabs
name='allen\thello'
print(name)
print(name.expandtabs(1))

##center,ljust,rjust,zfill
name='allen'
print(name.center(30,'-'))
print(name.ljust(30,'*'))
print(name.rjust(30,'*'))
print(name.zfill(50)) #用0填充

##captalize,swapcase,title
name='eGon'
print(name.capitalize()) #首字母大写,其余部分小写
print(name.swapcase()) #大小写翻转
msg='allen say hi'
print(msg.title()) #每个单词的首字母大写

##在python3中
num0='4'
num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字
 
 
##isdigt:str,bytes,unicode
print(num0.isdigit())
print(num1.isdigit())
print(num2.isdigit())
print(num3.isdigit())
print(num4.isdigit())
 
##isdecimal:str,unicode
num0='4'
num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字
print(num0.isdecimal())
print(num1)
print(num2.isdecimal())
print(num3.isdecimal())
print(num4.isdecimal())
 
##isnumeric:str,unicode,中文，罗马
num0='4'
num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字

print(num0.isnumeric())
print(num1)
print(num2.isnumeric())
print(num3.isnumeric())
print(num4.isnumeric())

##is其他
name='allen123'
print(name.isalnum()) #字符串由字母和数字组成
name='asdfasdfa sdf'
print(name.isalpha()) #字符串只由字母组成

name='asdfor123'
print(name.isidentifier()) # 用于判断字符串是否是有效的 Python 标识符，可用来判断变量名是否合法
name='allen'
print(name.islower())  # 检测字符串是否由小写字母组成
print(name.isupper())  # 检测字符串中所有的字母是否都为大写
print(name.isspace())  # 检测字符串是否只由空格组成
name='allen say'
print(name.istitle())  # 检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写

##作用：多个装备，多个爱好，多门课程，多个女朋友等

##定义：[]内可以有多个任意类型的值，逗号分隔
my_girl_friends=['lurac','wupeiqi','yuanhao',4,5] #本质my_girl_friends=list([...])
或
l=list('abc')

## 顾头不顾尾，步长
l=['a','b','c','d','e','f']
print(l[5])
print(l(-3))
## print(l[1:5])
## print(l[1:5:2])
## print(l[2:5])
## print(l[-1])
##了解
## print(l[-1:-4])
## print(l[-4:])
## print(l[-2:])

hobbies=['play','eat','sleep','study']
print(len(hobbies))

## in或者not in 一般用于if判断，
hobbies=['play','eat','sleep','study']
print('sleep' in hobbies)

msg='hello world allen'
print('allen' not in msg)

hobbies=['play','eat','sleep','study']
hobbies.append('girls')
print(hobbies)

## 指定索引插入
hobbies=['play','eat','sleep','study','eat','eat']
hobbies.insert(1,'walk')
hobbies.insert(1,['walk1','walk2','walk3'])
print(hobbies)
## ['play', ['walk1', 'walk2', 'walk3'], 'walk', 'eat', 'sleep', 'study', 'eat', 'eat']
## count 列表里包含的有几个；extend
print(hobbies.count('eat')) # 3
## extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
hobbies.extend(['walk1','walk2','walk3'])
## ['play', ['walk1', 'walk2', 'walk3'], 'walk', 'eat', 'sleep', 'study', 'eat', 'eat', 'walk1', 'walk2', 'walk3']

## 清空
hobbies=['play','eat','sleep','study','eat','eat']
hobbies.clear()
## []
## 复制
l=hobbies.copy()
print(l)
## ['play', 'eat', 'sleep', 'study', 'eat', 'eat']
## 翻转
l=[1,2,3,4,5]
l.reverse()
## [0, 5, 4, 3, 2, 1]
## 排序
## sort 与 sorted 区别：
## sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
## list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的list，而不是在原来的基础上进行的操作。
l=[100,9,-2,11,32]
l.sort(reverse=True)

l=sorted(l)
print(l)
## # [100, 32, 11, 9, -2]

hobbies=['play','eat','sleep','study']
x=hobbies.pop(1) #不是单纯的删除，是删除并且把删除的元素返回，我们可以用一个变量名去接收该返回值
print(x)
print(hobbies)

##了解
del hobbies[1] #单纯的删除
hobbies.remove('eat') #单纯的删除，并且是指定元素去删除

hobbies=['play','eat','sleep','study']
for l in hobbies:
   print(l)

queue_l=[]
##入队
queue_l.append('first')
queue_l.append('second')
queue_l.append('third')
print(queue_l)
##出队
print(queue_l.pop(0))
print(queue_l.pop(0))
print(queue_l.pop(0))

l=[]
##入栈
l.append('first')
l.append('second')
l.append('third')
##出栈
print(l)
print(l.pop())
print(l.pop())
print(l.pop())

##为何要有元组，存放多个值，元组不可变，更多的是用来做查询
##作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读
##定义：与列表类型比，只不过[]换成()
age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))

##1、按索引取值(正向取+反向取)：只能取  
##2、切片(顾头不顾尾，步长)
goods=('iphone','lenovo','sanxing','suoyi')
print(goods[1:3])
print(goods[-1])
print(goods[1:4:2])

print(len(goods))

##in:
##字符串:子字符串
##列表：元素
##元组：元素
##字典：key

goods=('iphone','lenovo','sanxing','suoyi')
print('iphone' in goods)看的是里面的元素在不在里面

d={'a':1,'b':2,'c':3}
print('b' in d) 看的是key在不在d里面

goods=('iphone','lenovo','sanxing','suoyi')
print(goods.index('iphone'))
print(goods.count('iphone')

##元组可以作为字典的key
d={(1,2,3):'allen'}
print(d,type(d),d[(1,2,3)])

##补充：元组本身是不可变的，但是内部的元素可以是可变类型
t=(1,['a','b'],'sss',(1,2)) #t=tuple((1,[1,3],'sss',(1,2)))
t[1][0]='A'
print(t)
## (1, ['A', 'b'], 'sss', (1, 2))
t[1]='eeeeeeeeeeeeeeeeeee'
## TypeError: 'tuple' object does not support item assignment

##作用：存多个值,key-value存取，取值速度快

##定义：key必须是不可变类型，value可以是任意类型
info={'name':'allen','age':18,'sex':'male'} #本质info=dict({....})
或
info=dict(name='allen',age=18,sex='male')
或
info=dict([['name','allen'],('age',18)])
或
{}.fromkeys(('name','age','sex'),None)

## 取
info_dic={'name':'allen','age':18,'sex':'male'}
print(info_dic['name'])
print(info_dic['name11111111'])#找不到则报错了
print(info_dic.get('name',None))
print(info_dic.get('name222222',None))#get方法找不到不报错，可以自己设定默认值

## 存
info_dic['hobbies']='大东区'
or
info_dic['hobbies']=[]
info_dic['hobbies'].append('study')
info_dic['hobbies'].append('read')
print(info_dic)
## {'name': 'allen', 'age': 18, 'sex': 'male', 'hobbies': ['study', 'read']}

## 修改
info_dic['level']=10
print(info_dic)

## 存+取
## setdefault() 方法和 get()方法 类似, 如果键不已经存在于字典中，将会添加键并将值设为默认值
## key存在则不设置默认，并且返回已经有的值
info_dic={'name':'allen','age':18,'sex':'male'}
info_dic.setdefault('hobbies',[1,2])
print(info_dic)
## {'name': 'allen', 'age': 18, 'sex': 'male', 'hobbies': [1, 2]}
info_dic.setdefault('hobbies',[1,2,3,4,5])
print(info_dic)
## {'name': 'allen', 'age': 18, 'sex': 'male', 'hobbies': [1, 2]}
info_dic.setdefault('hobbies',[]).append('study')
print(info_dic)
## {'name': 'allen', 'age': 18, 'sex': 'male', 'hobbies': [1, 2, 'study']}
l=info_dic.setdefault('hobbies',[])
print(l,id(l))
## [1, 2, 'study'] 7439112
print(id(info_dic['hobbies']))
## 7439112

## 存+修
## update() 有则修改，无则添加
info_dic={'name':'allen','age':18,'sex':'male'}
info_dic.update({'a':1,'name':'Allen','age':12})
print(info_dic)
## {'name': 'Allen', 'age': 12, 'sex': 'male', 'a': 1}

##pop：key存在则弹出值，不存在则返回默认值，如果没有默认值则报错
info_dic={'name':'allen','age':18,'sex':'male'}
print(info_dic.pop('nam123123123123123123e',None))
print(info_dic)

## Python 字典 popitem() 方法返回并删除字典中的最后一对键和值。
## 如果字典已经为空，却调用了此方法，就报出 KeyError 异常。
print(info_dic.popitem())
print(info_dic)

## 清空
del info_dic['name']

info_dic={'name':'allen','age':18,'sex':'male'}
print(info_dic.keys())
print(info_dic.values())
print(info_dic.items())
## dict_keys(['name', 'age', 'sex'])
## dict_values(['allen', 18, 'male'])
## dict_items([('name', 'allen'), ('age', 18), ('sex', 'male')])

for k in info_dic:             # 同样可以用 for k,v in info_dic.items():
    print(k,info_dic[k])
## name allen
## age 18
## sex male

## 长度
info_dic={'name':'allen','age':18,'sex':'male'}
print(len(info_dic))   # 3
## 复制
d=info_dic.copy()
print(d)
## 清空
info_dic.clear()
print(info_dic)

## eg:
s=set([1,2,2,3,3,3])
s={1, 2, 3}
type(l)=<class 'set'>

##1、长度len
##2、成员运算in和not in
##3、|合集
##4、&交集
##5、-差集
##6、^对称差集
##7、==
##8、父集：>,>= 
##9、子集：<,<=    

## 有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
pythons={'zhuzhuxia','allen','peiqi','gangdan'}
linuxs={'peiqi','allen','gangdan','feizhu'}
## 求出即报名python又报名linux课程的学员名字集合
print(pythons & linuxs) # {'peiqi', 'gangdan', 'allen'}
## 求出所有报名的学生名字集合
print(pythons | linuxs) # {'feizhu', 'zhuzhuxia', 'peiqi', 'gangdan', 'allen'}
## 求出只报名python课程的学员名字
print(pythons - linuxs) # {'zhuzhuxia'}
## 求出没有同时这两门课程的学员名字集合
print(pythons ^ linuxs) # {'feizhu', 'zhuzhuxia'}

linuxs = {'six', 'wu', 'dabao'}

linuxs.add('xiaoxiao')  # 说明set类型的集合是可变类型
## linuxs.add([1, 2, 3])  # 报错，只能添加不可变类型
res=linuxs.pop()  # 不用指定参数,随机删除,并且会有返回值
res=linuxs.remove('wupeiqi')#指定元素删除，元素不存在则报错，单纯的删除，没有返回值，
res=linuxs.discard('allen1111111111') #指定元素删除，元素不存在不报错，单纯的删除，没有返回值

## =========了解部分=========
linuxs={'wupeiqi','allen','susan','hiayan'}
new_set={'xxx','fenxixi'}
linuxs.update(new_set)
print(linuxs)
linuxs.copy()
linuxs.clear()
##解压
a,*_={'zzz','sss','xxxx','cccc','vvv','qqq'}
print(a) # 随机取一个值

## 1. 有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重，得到新列表,且新列表无需保持列表原来的顺序
l=['a','b',1,'a','a']
print(set(l))
## 2.在上题的基础上，保存列表原来的顺序
q=[]
for i in l:
    if i not in q:
        q.append(i)
print(q)
## 3.去除文件中重复的行，肯定要保持文件内容的顺序不变
import os
with open('db.txt','r',encoding='utf-8') as read_f,\
        open('.db.txt.swap','w',encoding='utf-8') as write_f:
    s=set()
    for line in read_f:
        if line not in s:
            s.add(line)
            write_f.write(line)
os.remove('db.txt')
os.rename('.db.txt.swap','db.txt')
## 4.有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表原来的顺序
l=[
    {'name':'allen','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'allen','age':20,'sex':'female'},
    {'name':'allen','age':18,'sex':'male'},
    {'name':'allen','age':18,'sex':'male'},
]
## 第一种方法
s=set()
l1=[]
for item in l:
    val=(item['name'],item['age'],item['sex'])
    if val not in s:
        s.add(val)
        l1.append(item)
print(l1)
## 第二种方法
##定义函数,既可以针对可以hash类型又可以针对不可hash类型
def func(items,key=None):
    s=set()
    for item in items:
        val=item if key is None else key(item)
        if val not in s:
            s.add(val)
            yield item

print(list(func(l,key=lambda dic:(dic['name'],dic['age'],dic['sex']))))

##身份运算（is ，is not）
is比较的是id，而双等号比较的是值
毫无疑问，id若相同则值肯定相同，而值相同id则不一定相同
x=1234567890
y=1234567890
x == y
## True
id(x),id(y)
## (3581040, 31550448)
x is y
## False

##1、打开编辑器就打开了启动了一个进程，是在内存中的，所以，用编辑器编写的内容也都是存放与内存中的，断电后数据丢失
##2、要想永久保存，需要点击保存按钮：编辑器把内存的数据刷到了硬盘上。
##3、在我们编写一个py文件（没有执行），跟编写其他文件没有任何区别，都只是在编写一堆字符而已。

##第一阶段：python解释器启动，此时就相当于启动了一个文本编辑器
##第二阶段：python解释器相当于文本编辑器，去打开test.py文件，从硬盘上将test.py的文件内容读入到内存中(小复习：pyhon的解释性，决定了解释器只关心文件内容，不关心文件后缀名)
##第三阶段：python解释器解释执行刚刚加载到内存中test.py的代码( ps：在该阶段，即真正执行代码时，才会识别python的语法，执行文件内代码，当执行到name="allen"时,会开辟内存空间存放字符串"allen")

　　计算机要想工作必须通电,即用‘电’驱使计算机干活,也就是说‘电’的特性决定了计算机的特性。电的特性即高低电平(人类从逻辑上将二进制数1对应高电平,二进制数0对应低电平)，关于磁盘的磁特性也是同样的道理。结论：计算机只认识数字

　　很明显，我们平时在使用计算机时，用的都是人类能读懂的字符（用高级语言编程的结果也无非是在文件内写了一堆字符），如何能让计算机读懂人类的字符？

　　必须经过一个过程：
　　#字符--------（翻译过程）------->数字 

　　#这个过程实际就是一个字符如何对应一个特定数字的标准，这个标准称之为字符编码

##1、一个python文件中的内容是由一堆字符组成的，存取均涉及到字符编码问题（python文件并未执行，前两个阶段均属于该范畴）

##2、python中的数据类型字符串是由一串字符组成的（python文件执行时，即第三个阶段）

首先明确概念
##1、文件从内存刷到硬盘的操作简称存文件
##2、文件从硬盘读到内存的操作简称读文件

乱码的两种情况：
##乱码一：存文件时就已经乱码
存文件时，由于文件内有各个国家的文字，我们单以shiftjis去存，
本质上其他国家的文字由于在shiftjis中没有找到对应关系而导致存储失败
但当我们硬要存的时候，编辑并不会报错（难道你的编码错误，编辑器这个软件就跟着崩溃了吗？？？），但毫无疑问，不能存而硬存，肯定是乱存了，即存文件阶段就已经发生乱码
而当我们用shiftjis打开文件时，日文可以正常显示，而中文则乱码了

##用open模拟编辑器的过程
可以用open函数的write可以测试，f=open('a.txt','w',encodig='shift_jis'
f.write('你瞅啥\n何を見て\n') #'你瞅啥'因为在shiftjis中没有找到对应关系而无法保存成功，只存'何を見て\n'可以成功

##以任何编码打开文件a.txt都会出现其余两个无法正常显示的问题
f=open('a.txt','wb')
f.write('何を見て\n'.encode('shift_jis'))
f.write('你愁啥\n'.encode('gbk'))
f.write('你愁啥\n'.encode('utf-8'))
f.close()

##乱码二：存文件时不乱码而读文件时乱码
存文件时用utf-8编码，保证兼容万国，不会乱码，而读文件时选择了错误的解码方式，比如gbk，则在读阶段发生乱码，读阶段发生乱码是可以解决的，选对正确的解码方式就ok了，

##reload与convert的区别：

pycharm非常强大，提供了自动帮我们convert转换的功能，即将字符按照正确的格式转换

要自己探究字符编码的本质，还是不要用这个

我们选择reload，即按照某种编码重新加载文件

文件test.py以gbk格式保存，内容为：

　　x='林'

无论是

　　python2 test.py

还是

　　python3 test.py

都会报错（因为python2默认ascii，python3默认utf-8）

除非在文件开头指定#coding:gbk

##1、保证不乱吗的核心法则就是，字符按照什么标准而编码的，就要按照什么标准解码，此处的标准指的就是字符编码

##2、在内存中写的所有字符，一视同仁，都是unicode编码，比如我们打开编辑器，输入一个“你”，我们并不能说“你”就是一个汉字，此时它仅仅只是一个符号，该符号可能很多国家都在使用，根据我们使用的输入法不同这个字的样式可能也不太一样。只有在我们往硬盘保存或者基于网络传输时，才能确定”你“到底是一个汉字，还是一个日本字，这就是unicode转换成其他编码格式的过程了

此时，python解释器会读取test.py的第一行内容，#coding:utf-8，来决定以什么编码格式来读入内存，这一行就是来设定python解释器这个软件的编码使用的编码格式这个编码，

可以用sys.getdefaultencoding()查看，如果不在python文件指定头信息＃-*-coding:utf-8-*-,那就使用默认的

python2中默认使用ascii，python3中默认使用utf-8 

##coding:gbk
你好啊

内存的编码使用unicode，不代表内存中全都是unicode，

在程序执行之前，内存中确实都是unicode,比如从文件中读取了一行x="allen",其中的x，等号，引号，地位都一样，都是普通字符而已，都是以unicode的格式存放于内存中的

但是程序在执行过程中，会申请内存（与程序代码所存在的内存是俩个空间）用来存放python的数据类型的值，而python的字符串类型又涉及到了字符的概念

比如x="allen",会被python解释器识别为字符串，会申请内存空间来存放字符串类型的值，至于该字符串类型的值被识别成何种编码存放，这就与python解释器的有关了，而python2与python3的字符串类型又有所不同。 

##coding:gbk
x='上'
y='下'
print([x,y]) #['\xc9\xcf', '\xcf\xc2']
##\x代表16进制，此处是c9cf总共4位16进制数，一个16进制四4个比特位，4个16进制数则是16个比特位，即2个Bytes，这就证明了按照gbk编码中文用2Bytes

print(type(x),type(y)) #(<type 'str'>, <type 'str'>)

x=‘你a好’
转成gbk格式二进制位
8bit+8bit+8bit+8bit+8bit=(1+7bit)+(1+7bit)+(0+7bit)+(1+7bit)+(1+7bit)

##连续读到前两个括号内的首位标志位均为1，则构成一个中午字符：你

##读到第三个括号的首位标志为0，则该8bit代表一个英文字符：a

##连续读到后两个括号内的首位标志位均为1，则构成一个中午字符：好

(7bit)+(7bit)+(7bit)+(7bit)+(7bit)

##coding:gbk
x='上'.decode('gbk')
y='下'.decode('gbk')
print([x,y]) #[u'\u4e0a', u'\u4e0b']

##coding:gbk
x=u'上' #等同于 x='上'.decode('gbk')
y=u'下' #等同于 y='下'.decode('gbk')
print([x,y]) #[u'\u4e0a', u'\u4e0b']
print(type(x),type(y)) #(<type 'unicode'>, <type 'unicode'>)

##coding:gbk
x='上' #当程序执行时，无需加u，'上'也会被以unicode形式保存新的内存空间中,

print(type(x)) #<class 'str'>

##x可以直接encode成任意编码格式
print(x.encode('gbk')) #b'\xc9\xcf'
print(type(x.encode('gbk'))) #<class 'bytes'>

age_of_girl=31
if age_of_girl > 30:
    print('阿姨好')

age_of_girl=18
if age_of_girl > 30:
    print('阿姨好')
else:
    print('小姐好')

age_of_girl=18
height=171
weight=99
is_pretty=True
if age_of_girl >= 18 and age_of_girl < 22 and height > 170 and weight < 100 and is_pretty == True:
    print('表白...')else:
    print('阿姨好')

##在表白的基础上继续：
##如果表白成功，那么：在一起
##否则：打印。。。

age_of_girl=18
height=171
weight=99
is_pretty=True

success=False

if age_of_girl >= 18 and age_of_girl < 22 and height > 170 and weight < 100 and is_pretty == True:
    if success:
        print('表白成功,在一起')
    else:
        print('什么爱情不爱情的,爱nmlgb的爱情,爱nmlg啊...')
else:
    print('阿姨好')

score=input('>>: ')
score=int(score)

if score >= 90:
    print('优秀')
elif score >= 80:
    print('良好')
elif score >= 70:
    print('普通')
else:
    print('很差')

　　if 条件1:
　　　　缩进的代码块
　　elif 条件2:
　　　　缩进的代码块
　　elif 条件3:
　　　　缩进的代码块
　　else:　　
　　　　缩进的代码块

## 练习一：用户登陆验证
##!/usr/bin/env python
name=input('请输入用户名字：')
password=input('请输入密码：')

if name == 'allen' and password == '123':
    print('allen login success')
else:
    print('用户名或密码错误')

##练习二：根据用户输入内容输出其权限
##!/usr/bin/env python
##根据用户输入内容打印其权限

'''
egon --> 超级管理员
tom  --> 普通管理员
jack,rain --> 业务主管
其他 --> 普通用户
'''
name=input('请输入用户名字：')

if name == 'allen':
    print('超级管理员')
elif name == 'tom':
    print('普通管理员')
elif name == 'jack' or name == 'rain':
    print('业务主管')
else:
    print('普通用户')

## 练习三
## 如果:今天是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
    ''')

##上节课我们已经学会用if .. else 来猜年龄的游戏啦，但是只能猜一次就中的机率太小了，如果我想给玩家3次机会呢？就是程序启动后，玩家最多可以试3次，这个怎么弄呢？你总不会想着把代码复制3次吧。。。。

age_of_oldboy = 48

guess = int(input(">>:"))

if guess > age_of_oldboy :
    print("猜的太大了，往小里试试...")

elif guess < age_of_oldboy :
    print("猜的太小了，往大里试试...")

else:
    print("恭喜你，猜对了...")

##第2次
guess = int(input(">>:"))

if guess > age_of_oldboy :
    print("猜的太大了，往小里试试...")

elif guess < age_of_oldboy :
    print("猜的太小了，往大里试试...")

else:
    print("恭喜你，猜对了...")

##第3次
guess = int(input(">>:"))

if guess > age_of_oldboy :
    print("猜的太大了，往小里试试...")

elif guess < age_of_oldboy :
    print("猜的太小了，往大里试试...")

else:
    print("恭喜你，猜对了...")

##即使是小白的你，也觉得的太low了是不是，以后要修改功能还得修改3次，因此记住，写重复的代码是程序员最不耻的行为。
那么如何做到不用写重复代码又能让程序重复一段代码多次呢？ 循环语句就派上用场啦

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='allen'
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='allen'
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用于退出本层循环
while True:
    print "123"
    break
    print "456"

##continue用于退出本次循环，继续下一次循环
while True:
    print "123"
    continue
    print "456"

##与其它语言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 ------

##1. 使用while循环输出1 2 3 4 5 6     8 9 10
##2. 求1-100的所有数的和
##3. 输出 1-100 内的所有奇数
##4. 输出 1-100 内的所有偶数
##5. 求1-2+3-4+5 ... 99的所有数的和
##6. 用户登陆（三次机会重试）
##7：猜年龄游戏
要求：
    允许用户最多尝试3次，3次都没猜对的话，就直接退出，如果猜对了，打印恭喜信息并退出
##8：猜年龄游戏升级版 
要求：
    允许用户最多尝试3次
    每尝试3次后，如果还没猜对，就问用户是否还想继续玩，如果回答Y或y, 就继续让其猜3次，以此往复，如果回答N或n，就退出程序
    如何猜对了，就直接退出 

##题一
count=1
while count <= 10:
    if count == 7:
        count+=1
        continue
    print(count)
    count+=1
    

count=1
while count <= 10:
    if count != 7:
        print(count)
    count+=1
    

##题目二
res=0
count=1
while count <= 100:
    res+=count
    count+=1
print(res)

##题目三
count=1
while count <= 100:
    if count%2 != 0:
        print(count)
    count+=1
    
##题目四
count=1
while count <= 100:
    if count%2 == 0:
        print(count)
    count+=1
    
    
##题目五
res=0
count=1
while count <= 5:
    if count%2 == 0:
        res-=count
    else:
        res+=count
    count+=1
print(res)
    

##题目六
count=0
while count < 3:
    name=input('请输入用户名：')
    password=input('请输入密码：')
    if name == 'allen' and password == '123':
        print('login success')
        break
    else:
        print('用户名或者密码错误')
        count+=1

##题目七
age_of_oldboy=73

count=0
while count < 3:
    guess=int(input('>>: '))
    if guess == age_of_oldboy:
        print('you got it')
        break
    count+=1

##题目八
age_of_oldboy=73

count=0
while True:
    if count == 3:
        choice=input('继续(Y/N?)>>: ')
        if choice == 'Y' or choice == 'y':
            count=0
        else:
            break

    guess=int(input('>>: '))
    if guess == age_of_oldboy:
        print('you got it')
        break
    count+=1

for i in range(1,10):
    for j in range(1,i+1):
        print('%s*%s=%s' %(i,j,i*j),end=' ')
    print() 

##分析
'''

             #max_level=5
    *        #current_level=1，空格数=4，*号数=1
   ***       #current_level=2,空格数=3,*号数=3
  *****      #current_level=3,空格数=2,*号数=5
 *******     #current_level=4,空格数=1,*号数=7
*********    #current_level=5,空格数=0,*号数=9

##数学表达式
空格数=max_level-current_level
*号数=2*current_level-1

'''

##实现
max_level=5
for current_level in range(1,max_level+1):
    for i in range(max_level-current_level):
        print(' ',end='') #在一行中连续打印多个空格
    for j in range(2*current_level-1):
        print('*',end='') #在一行中连续打印多个空格
    print()

for i in range(10)
	循环执行的代码体
else:
     循环结束后执行的代码体

##1. 打开文件，得到文件句柄并赋值给一个变量
##2. 通过句柄对文件进行操作
##3. 关闭文件

##1. 打开文件，得到文件句柄并赋值给一个变量
f=open('a.txt','r',encoding='utf-8') #默认打开模式就为r

##2. 通过句柄对文件进行操作
data=f.read()

##3. 关闭文件
f.close()

##1、由应用程序向操作系统发起系统调用open(...)

##2、操作系统打开该文件，并返回一个文件句柄给应用程序

##3、应用程序将文件句柄赋值给变量f

##强调第一点：
打开一个文件包含两部分资源：操作系统级打开的文件+应用程序的变量。在操作完毕一个文件时，必须把与该文件的这两部分资源一个不落地回收，回收方法为：
1、f.close() #回收操作系统级打开的文件
2、del f #回收应用程序级的变量

其中del f一定要发生在f.close()之后，否则就会导致操作系统打开的文件还没有关闭，白白占用资源，
而python自动的垃圾回收机制决定了我们无需考虑del f，这就要求我们，在操作完毕文件后，一定要记住f.close()

虽然我这么说，但是很多同学还是会很不要脸地忘记f.close(),对于这些不长脑子的同学，我们推荐傻瓜式操作方式：使用with关键字来帮我们管理上下文
with open('a.txt','w') as f:
    pass
 
with open('a.txt','r') as read_f,open('b.txt','w') as write_f:
    data=read_f.read()
    write_f.write(data)

##强调第二点：
f=open(...)是由操作系统打开文件，那么如果我们没有为open指定编码，那么打开文件的默认编码很明显是操作系统说了算了，操作系统会用自己的默认编码去打开文件，在windows下是gbk，在linux下是utf-8。
这就用到了上节课讲的字符编码的知识：若要保证不乱码，文件以什么方式存的，就要以什么方式打开。

f=open('a.txt','r',encoding='utf-8')

##首先在python3中操作文件只有一种选择，那就是open()

##而在python2中则有两种方式：file()与open()
两者都能够打开文件，对文件进行操作，也具有相似的用法和参数，但是，这两种文件打开方式有本质的区别，file为文件类，用file()来打开文件，相当于这是在构造文件类，而用open()打开文件，是用python的内建函数来操作，我们一般使用open()打开文件进行操作，而用file当做一个类型，比如type(f) is file

文件句柄 = open('文件路径', '模式')

##1. 打开文件的模式有(默认为文本模式)：
r ，只读模式【默认模式，文件必须存在，不存在则抛出异常】
w，只写模式【不可读；不存在则创建；存在则清空内容】
a， 之追加写模式【不可读；不存在则创建；存在则只追加内容】

##2. 对于非文本文件，我们只能使用b模式，"b"表示以字节的方式操作（而所有文件也都是以字节的形式存储的，使用这种模式无需考虑文本文件的字符编码、图片文件的jgp格式、视频文件的avi格式）
rb 
wb
ab
注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型，不能指定编码

##3. 了解部分
"+" 表示可以同时读写某个文件
r+， 读写【可读，可写】
w+，写读【可读，可写】
a+， 写读【可读，可写】


x， 只写模式【不可读；不存在则创建，存在则报错】
x+ ，写读【可读，可写】
xb