Python数据类型和分支循环

了解过了Python的发展历史，现在开始我们的Python基础吧，如果你有学习过其他的编程语言，你可以跳过这一篇

PyCharm使用图解

开发python的工具你可以自己选择， 这里我推荐的是PyCharm界面操作和webstorm一样，要是你弄过前端，肯定很熟悉

软件的下载安装步骤，可以看下这个文章：
http://blog.csdn.net/qq_29883...

安好之后呢，来创建一个项目，写一句满满仪式感的hello world
File->New Project ..

这个地方选择你的python安装路径，点击create即可完成创建，项目创建好了，开始创建我们的文件

最后运行一下

变量

什么是变量？给你一个官方一点的回答：
变量指向各种类型值的名字，以后再用到这个值时，直接引用名字即可

Python中定义一个变量的语法：

name="小明" #变量名=变量对应的值
name=input("请输入姓名")

这样我们就成功的定义一个变量，和其他编程语言不一样的是变量没有数据类型的修饰，这就是前面我们说过的动态类型，变量的类型由值来决定
问：噗，还有一个问题上面那个#号什么鬼
答：在python中#为单行注释，多行注释 ''' 注释内容 '''
问：那input又是什么
答：python3.X里input是接收用户输入，这个时候会让你输入姓名并赋值给变量name,在python2.X里面时raw_input

变量的命名规则：

1. 变量名只能是 字母、数字或下划线的任意组合
2. 变量名的第一个字符不能是数字
3. 不能使用python中的关键字

Python3中共有33个关键字，都不能作为变量名来使用：
False/None/True/and/as/assert/break/class/continue/def/del/elif/else/except/finally/for/from/global/if/import/in/nonlocal/lambda/is/not/or/pass/raise/return/try/while/with/yield

数据类型

Python中数据类型：

1. Number(数字) Python3支持3种不同的数值类型：整型(int)、浮点型(float)、复数(complex)
2. 布尔值(真或假)
3. String(字符串)
4. List(列表)
5. Tuple(元组)
6. Sets(集合)
7. Dictionary(字典)

小故事：为什么叫布尔值? 为了纪念一个人他的名字叫布尔，他出版的《逻辑的数学分析》、《思维规律的研究》以他名字命名布尔代数，因为他在符号逻辑运算中做的的特殊贡献，很多计算机语言中将逻辑运算称为布尔运算，运算的结果称为布尔值

通过type()来查看数据类型

Microsoft Windows [版本 6.1.7601]
版权所有 (c) 2009 Microsoft Corporation。保留所有权利。

C:\Users\Administrator>python
Python 3.6.3 (v3.6.3:2c5fed8, Oct  3 2017, 17:26:49) [MSC v.1900 32 bit (Intel)]
 on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> type("张三")
<class 'str'>
>>>

此外还可以用 isinstance 来判断：

a = 111
isinstance(a, int)
True

isinstance 和 type 的区别在于：

class A:
    pass

class B(A):
    pass

print(isinstance(A(),A)) # True
print(isinstance(B(),A)) # True
print(type(A())==A)      # True
print(type(B())==A)      # False
#type()不会认为子类是一种父类类型。isinstance()会认为子类是一种父类类型。

当然数据类型也可以进行转换

>>> type("张三")
<class 'str'>
>>> type(int("18"))
<class 'int'>
>>>

数据类型转换

#一、数据类型转换
# number="1"
# number=1
# number="True"
# number="aa,bb,cc"
# number=65
number="A"
print(type(number))
print(number)
# number1=int(number) #转换为int
# number1=float(number) #转换为float
# number1=str(number) #转换为str
# number1=bool(number) #转换为str
# number1=list(number) #转换为一个列表
# number1=chr(number) #将一个整数转换为一个字符
# number1=ord(number) #将一个字符转换为它的整数值
print(type(number1))
print(number1)

字符串

字符串(String)是由数字、字母、下划线组成的一串字符。一般用一对单引号或双引号或三引号来包裹。一般记为 : s = "a1a2···an" 它是编程语言中表示文本的数据类型。
转义字符：在需要在字符中使用特殊字符时，python用反斜杠()转义字符。

python的字符串列表有2种取值顺序:

1. 从左到右索引默认0开始的，最大范围是字符串长度少1
2. 从右到左索引默认-1开始的，最大范围是字符串开头

如果你要实现从字符串中获取一段子字符串的话，可以使用变量 [头下标:尾下标]，就可以截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。 比如:

s = 'ilovepython'
# s[1:5]的结果是love。

使用上述方式获取的新字符串为“love”。而s[1]的值为 l，s[5]的值为p。
不难发现：上面的结果包含了左边界的值（s[1]`的值l），而不包括右边界的值（s[5]的值p）。
加号（+）是字符串连接运算符，星号（*）是重复操作。如下实例：

str = 'Hello World!'
str=R"helloPython"
print('ha' not in str)
print(str)          # 输出完整字符串
print(str[0])        # 输出字符串中的第一个字符
print(str[2:5])      # 输出字符串中第三个至第五个之间的字符串
print(str[2:])       # 输出从第三个字符开始的字符串
print(str * 2 )      # 输出字符串两次
print(str + "TEST")  # 输出连接的字符串 
#完整版
str=" Hello python ll5 "
print(str.capitalize()) #将字符串的第一个字符转换为大写
#Python count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
print(str.count('l',0,10)) 
'''
sub – 搜索的子字符串 
start – 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。 
end –字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。
'''
print(str.count('l'))
print(str.endswith('l')) #是否以l结尾返回true 和 false
print(str.endswith('o',0,5)) #在指定的范围内以什么结尾
print(str.find('wl')) 
print(str.index('l')) #跟find()方法一样，只不过如果str不在字符串中会报一个异常.
print(str.isalnum()) #如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False(包含其他符号都是false)
print(str.isalpha()) #如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
print(str.isdigit()) #如果字符串只包含数字则返回 True 否则返回 False..
print(len(str)) #返回字符串长度
print(str.lower()) #转换字符串中所有大写字符为小写.
print(str.upper()) #转换字符串中的小写字母为大写
print(str.swapcase()) #将字符串中大写转换为小写，小写转换为大写
print(str.lstrip()) #截掉字符串左边的空格或指定字符。
print(str.rstrip()) #删除字符串字符串末尾的空格.
print(str.strip(str)) #在字符串上执行 lstrip()和 rstrip()

布尔值

布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来：

>>> True
True
>>> False
False
>>> 3 > 2
True
>>> 3 > 5
False

布尔值可以用and、or和not运算。and运算是与运算，只有所有都为True，and运算结果才是True：布尔值经常用在条件判断中

列表

List（列表） 是 Python 中使用最频繁的数据类型。列表用 [ ] 标识，是 python 最通用的复合数据类型,应该不会有疑问列表是什么吧，举个例子，喜洋洋是一只羊，那么羊村里面的羊是不是就应该用列表来表示了。list是python中内置的一种数据类型，可以随时添加和删除其中的元素。

list1 = ['Google', 'Baidu', 1997, 2000];

print(list1[-2]) #从右侧开始读取，-1开始
print(list1[1:])#输出从第二个元素开始后的所有元素
print(len(list1)) #返回列表长度
print([1, 2, 3] + [4, 5, 6]) #组合
print(list1*4) #重复
print(1997 in list1) #元素是否存在于列表中
#迭代
for x in list1: 
    print(x)
#列表嵌套
list2=[1,2,3]    
list1=["baidu",list2]
print(list1[1][5]) #输出2
print(max([1,2,3])) #输出3
print(min([1,2,3])) #输出1
yangcun=["喜洋洋","美羊羊","懒洋洋"]#定义一个列表
print(yangcun)
#列表基础操作
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
# list.clear()
# list.reverse()
print(list)               # 输出完整列表
print(list[0])            # 输出列表的第一个元素
print(list[1:3])          # 输出第二个至第三个的元素 
print(list[2:] )          # 输出从第三个开始至列表末尾的所有元素
print(tinylist * 2)       # 输出列表两次
print(list + tinylist)    # 打印组合的列表

问：如何获取到列表的某一个元素呢？
答：通过索引的方式，注意索引从0开始yangcun[0]即为喜洋洋
问：索引可以为负数么
答：如果yangcun[-1]即取到最后一个元素，依次类推
问：羊村如果来了新羊怎么办
答：yangcun.append("沸羊羊")
问：新来的小羊可以选择自己喜欢的位置么
答：yangcun.insert(1,"沸羊羊")这样沸羊羊就跑到美羊羊前面了
问：美羊羊的名字打错了，怎么办
答：别担心，yangcun[1]="美洋洋" 就可以了
问：灰太狼来了，我想找到喜洋洋在哪，怎么找到喜洋洋的索引呢
答：yangcun.index("喜洋洋")
问：那万一有小羊被灰太狼抓走了羊村的羊少了怎么表示
答：yangcun.pop() 即删除list末尾的元素，yangcun.pop(1) 删除指定索引位置的元素
问：yangcun[1:3] 这是什么语法
答：这是python中的分片，意思是取索引为1和2的元素 (其实很好记，就是顾头不顾尾，所以索引不包含3本身)

呼呼~ 一连串的问题下来大家应该get到了基本的列表操作，当然这还不够全，你可以输入完列表名称.后看下给出的提示上面的方法都可以试一试。

yangcun=["喜洋洋","美羊羊","懒洋洋",["小羊1","小羊2"]]
xinyangcun=yangcun.copy();
yangcun2=yangcun[:];
yangcun[3][0]="小小羊"
print(xinyangcun[3][0]) #问：输出结果时什么
print(yangcun2) #问：输出什么

理解列表：

1. 输出的是小小羊，这个和列表的内存存储方式有关，xinyangcun只是指向了和yangcun一样的内存地址，但是当这块空间的内容变了，最后输出的内容肯定就变了，反过来即你改变xinyangcun的值yangcun也会跟着变。
2. 输出["喜洋洋","美羊羊","懒洋洋",["小羊1","小羊2"]]

元组

元素和列表概念上其实是一样的，最大的区别是元组一旦创建不能修改，所以可以成为只读列表,定义上用()

yangcun=("喜洋洋","美羊羊","懒洋洋")
print(yangcun[0]) #喜洋洋
#元组基础操作
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')

print(tuple)               # 输出完整元组
print(tuple[0])            # 输出元组的第一个元素
print(tuple[1:3])          # 输出第二个至第三个的元素 
print(tuple[2:])           # 输出从第三个开始至列表末尾的所有元素
print(tinytuple * 2)       # 输出元组两次
print(tuple + tinytuple)   # 打印组合的元组

那么元组和列表区别：

1. Tuples are immutable, lists are mutable.（元组是不可变的， 而列表是可变的）
2. 元组通常由不同的数据，而列表是相同类型的数据队列。元组表示的是结构，而列表表示的是顺序。
3. 你不能将列表当作字典的key， 而元组可以。
4. 由于元组支持的操作比列表小， 所以元组会比列表稍快

a=(1,2)
b=[4,5]

c={a:"tuples"}
c={b:"list"}

字符串的一些常用方法

title=" hello world "

print(title.capitalize()) #Hello world 首字母大写
print(title.casefold()) #全部转换为小写
print(title.upper()) #全部转换为大写
print(title.swapcase()) #大小写互转
print(title.center(30,"-")) #---------hello world----------
print(title.find("h")) #查找返回索引 0，找不到返回-1
print(title.index('h'))#返回所在索引
print(title.endswith("com"))#判断是否以com结尾 False
print(title.strip()) #删除字符串两边的指定字符，括号的写入指定字符，默认为空格
print(len(title)) #字符串长度
print(title.count('l'))#字符串统计，出现的次数
print(title.replace('l', 'a'))  #替换字符串
print(title.split(' ')) #字符串分隔
print("aa".isalpha())  # 是否是英文字母，返回布尔值
print("111".isdigit())  # 是否是数字，返回布尔值
print('_name'.isidentifier())  # 是否是一个合法的变量名，返回布尔值
print('aaaAAAA'.islower())  # 是否是小写字母，返回布尔值
print('AAAAA'.isupper())  # 是否是大写字母，返回布尔值

字典

字典一种key - value 的数据类型，使用就像我们上学用的字典，通过笔划、字母来查对应页的详细内容，字典中没有下标是无序的

列表和字典两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过索引存取。
字典的创建格式如下：注意键必须唯一

d={key1:value1,key2:value2}
#字典基础操作
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"

tinydict = {'name': 'john','code':6734, 'dept': 'sales'}


print(dict['one'])          # 输出键为'one' 的值
print(dict[2])              # 输出键为 2 的值
print(tinydict)             # 输出完整的字典
print(tinydict.keys())      # 输出所有键
print(tinydict.values())    # 输出所有值

moviesdict={
    "芳华":"黄轩",
    "心理罪":"邓超"
}
print(moviesdict.items())
print(moviesdict.keys())
print(moviesdict.values())
print("芳华" in moviesdict) #指定的key在列表中是否存在
# print(moviesdict.pop("芳华"))#根据指定的key删除
# print(moviesdict.keys())
print(moviesdict.popitem()) #删除，末尾元素
# moviesdict.clear()
print(moviesdict.keys()) 
print(moviesdict.get("芳华")) #根据key找value

字典常用方法：

yang={
    "y1":"美羊羊",
    "y2":"懒洋洋",
    "y3":"喜洋洋",
    "y4":"沸羊羊"
}
#添加
yang["y5"]="慢羊羊"
#通过key来取值
print(yang["y1"])
#修改
yang["y1"]="美羊羊1"
print(yang)
#删除
del yang["y1"]
print(yang)
#查找
print(yang.get("y2"))
print(yang.keys());#获取所有的key
print(yang.items())

集合set

集合就像舍弃了值，仅剩下键的字典一样，键与键之间也不允许重复，如果你仅仅想知道某一个元素是否存在而不关心其他的，使用集合是一个非常不错的选择，如果需要为键附加其他信息的话，建议使用字典
set是无序的集合，不能有重复的元素，也不能排序，sort()是不能使用的。同列表相比set验证元素是否存在会更快。注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建一个set：myset = {3, 4, 5, 1}
type(myset) 输出 set

运算符

Python运算符分类:

1. 算数运算符（+ - / /% * //）
2. 关系运算符（== != > < >= <=）
3. 赋值运算符（= += -= = /= %= *= //=）
4. 逻辑运算符（and or not ）
5. 位运算符（& | ^ ~ << >>）
6. 成员运算符（in not in）
7. 身份运算符（is is not）

以上的运算符其实看字面意思都可以，这里挑几个和其他语言中不一样的运算符做下解释：
** ：幂，返回x 的 y次幂
// ：返回商的整数部分
in ：如果在指定的序列中找到值，就返回True，否则false
is ：is 判断两个标识符是否引用自一个对象

分支语句

分支又称为流程控制，什么意思呢，也就是计算机其实比较傻的，如果你不告诉它该怎么执行，它会从第一行按序一行一行执行，但是我们的程序都是有逻辑，就是指挥计算机应该怎么执行我们写的代码。

要是上面我写的这一长串，你懒得看的话，可以看看下图(喜洋洋与灰太狼)帮助你更好的理解分支语句
][8]

huitailang="灰太狼"

#基础用法
# hongtailang=input("请输入红太狼想不想吃羊:")
# if hongtailang=="吃羊":
#     # 坑
#       print("红太狼逼灰太狼去抓羊")
#       print("啦啦啦啦啦") 
# else:
#     print("灰太狼自己去抓羊")    
#     print("lalla")

#多条件：else if 存在多个，但是不能独立出现，必须和if ,可以没有else
# yang=input("灰太狼抓到了哪只羊:")
# if yang=="喜洋洋":
#     print("成功逃离")
# elif yang=="美羊羊":
#     print("等待喜洋洋来就她")
# elif yang=="懒洋洋":
#     print("哭")
# else:
#     print("吃了")      

#分支嵌套：不建议嵌套太多层 3
hongtailang=input("请输入红太狼想不想吃羊:")
if hongtailang=="吃羊":
    yang=input("灰太狼抓到了哪只羊:")
    if yang=="喜洋洋":
        print("成功逃离")
    elif yang=="美羊羊":
        print("等待喜洋洋来就她")
    elif yang=="懒洋洋":
        print("哭")
    else:
        print("吃了") 
else:
    print("灰太狼自己去抓羊")    

要是用代码来试下应该怎么做

huitailang="灰太狼"
hongtailang=input("红太狼是否想吃羊：")
if hongtailang=="吃羊":
    print("红太狼逼灰太狼去抓羊")
else:
    print("{name}自己去抓羊".format(name=huitailang))

语法上面和其他语言并没有变化太多，缩进这种语法当你看习惯了就会发现很不错
问：print前面的缩进或者那个冒号删了可以么
答：都不可以删，会报语法错误
问：python中是否和其他语言中一样存在else if ?
答：当然，但是不叫else if ，算是一个小简写 elif ，注意elif不能单独使用，必须和if 结合使用

上面的if弄明白了么，我们来加点料做个if的嵌套，情景：当灰太狼遇见喜洋洋

huitailang="灰太狼"
xiyangyang="喜洋洋"
hongtailang=input("红太狼是否想吃羊：")
if hongtailang=="吃羊":
    print("红太狼逼灰太狼去抓羊")
else:
    print("{name}自己去抓羊".format(name=huitailang))
    yang=input("抓到哪只羊：")
    if yang==xiyangyang:
        print("成功逃离")
    else:
        print("抓到羊")

循环语句

循环很好理解，循环也就是重复，重复某一个语句

第一种：while循环,来大家和我一起写下面的代码执行下

while True:
    print("当条件成立的时候执行")

大家看到什么结果？为了让大家对这个循环条件的作用理解深刻一些，发现一不小心写了一个死循环，这也是我们写循环的禁忌，怎么能避免死循环，也很简单，在循环体内一定要有改变循环条件的代码即可。

刚刚上图的喜洋洋与灰太狼里，灰太狼什么时候才能抓到羊还记得么，是不是怒气值到3的时候，那么我们来用代码模拟下

nuqizhi=0;  #怒气值
while nuqizhi<3:
    nuqizhi = nuqizhi + 1
    print("怒气值为"+str(nuqizhi))
if nuqizhi==3:
    print("怒气值够了抓到羊")

第二种：for循环 我们用for 来数一数羊村里面的羊吧

yangcun=["喜洋洋","懒洋洋","美羊羊","沸羊羊"]
for yang in yangcun:
    print(yang)

输出结果：
喜洋洋
懒洋洋
美羊羊
沸羊羊

怎么跳转循环（break、continue）

yangcun=["喜洋洋","懒洋洋","美羊羊","沸羊羊"]
for yang in yangcun:
    if yang=="美羊羊":
        break;
    print(yang)

输出结果：
喜洋洋
懒洋洋

yangcun=["喜洋洋","懒洋洋","美羊羊","沸羊羊"]
for yang in yangcun:
    if yang=="美羊羊":
        continue;
    print(yang)

输出结果：
喜洋洋
懒洋洋
沸羊羊

Python的执行过程

在上一章我们给大家介绍了什么是编译型语言、什么是解释型语言，
当然还有混合型比如JAVA,JAVA执行过程是通过编译器编译成字节码文件，然后在运行时通过解释器给解释成机器文件，所以JAVA是先编译后解释的语言。

而python是一门解释型语言，那么有没有注意到.pyc文件(在安装路径下的__pycache__文件夹下)，其实Python当你去执行的时候，它也做了编译同JAVA一样，在执行之前编译并把编译的结果保存在内存中，结束后写入到.pyc文件里。第二次再运行就会先读.pyc文件，要是没有这个文件，就去执行编译写入的步骤。

最后小小总结一下

通过上面你应该get到的Python基础语法，数据类型，分支，循环