Python数据类型和分支循环

摘要：会认为子类是一种父类类型。一般记为它是编程语言中表示文本的数据类型。运算是与运算，只有所有都为，运算结果才是布尔值经常用在条件判断中列表列表是中使用最频繁的数据类型。是中内置的一种数据类型，可以随时添加和删除其中的元素。

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

开发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

变量的命名规则：

变量名只能是 字母、数字或下划线的任意组合

变量名的第一个字符不能是数字

不能使用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中数据类型：

Number(数字) Python3支持3种不同的数值类型：整型(int)、浮点型(float)、复数(complex)

布尔值(真或假)

String(字符串)

List(列表)

Tuple(元组)

Sets(集合)

Dictionary(字典)

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

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

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

C:UsersAdministrator>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("张三")

>>>

此外还可以用 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("张三")

>>> type(int("18"))

>>>

#一、数据类型转换
# 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种取值顺序:

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

从右到左索引默认-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) #问：输出什么

理解列表：

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

输出["喜洋洋","美羊羊","懒洋洋",["小羊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)   # 打印组合的元组

那么元组和列表区别：

Tuples are immutable, lists are mutable.（元组是不可变的， 而列表是可变的）

元组通常由不同的数据，而列表是相同类型的数据队列。元组表示的是结构，而列表表示的是顺序。

你不能将列表当作字典的key， 而元组可以。

由于元组支持的操作比列表小， 所以元组会比列表稍快

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是无序的集合，不能有重复的元素，也不能排序，sort()是不能使用的。同列表相比set验证元素是否存在会更快。注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建一个set：myset = {3, 4, 5, 1}
type(myset) 输出 set

Python运算符分类:

算数运算符（+ - / /% * //）

关系运算符（== != > < >= <=）

赋值运算符（= += -= = /= %= *= //=）

逻辑运算符（and or not ）

位运算符（& | ^ ~ << >>）

成员运算符（in not in）

身份运算符（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)

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

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

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

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