python2

1、算数运算符：

    + - * /  取模%（返回除法余数）   幂**    取整除//

    python 2.7 中默认取整除
        需导入模块，结果才为保留小数
        #from __future__ import division
2、比较运算符：
    ==     不等于!=、<>     >    <    >=   <=

3、赋值运算符：
    =     +=      -=      *=      /=        %=        **=         //=

4、逻辑运算符：
    and 布尔“与”       or 布尔“或”      not 布尔“非”

5、成员运算符：
    in        not in

6、身份运算符：






================================================================================
pycharm
    1、模板
    file=>settings=>Editor=>file and code template => Python Script  #设置头代码
        #!/usr/bin/env python
        # -*- coding:utf-8 -*-

    OK

    2、文字大小
    file=>settings=>editor=>color and font=>font=>save as.. =>修改字号

    3、运行
        a、点击要运行的文件，右键run
        b、
            view=>toolbar
            选中要执行的文件
            点击 > 运行

        c、在当前文件空白处，右键，run

    4、切换python版本
        file ->settings -> project interpreter ->选择版本




================================================================================
基本数据类型
    数字    int
    字符串  str
    布尔值  bool
    列表    list
    元组    tuple
    字典    dict
    所有字符串或数字、字典…… 所具备的方法存在相对应的“值”里

    所有对象所具备的功能都保存在相应的类中


查看对象的类，或对象所具备的功能

1、type
    temp = "alex"
    t = type(temp)
    print (t)
    # str, ctr+鼠标左键，找到str类内部所有的方法

2、dir
    temp = "alex"
    b = dir(temp)
    #显示类内部所有的方法名称

3、help，type
    help(type(temp))
    #显示类内部所有方法的名称和详细信息

4、直接点击
    temp = "alex"
    temp.upper()

    鼠标放在upper()上，ctrl+左键，自动定位到upper功能处


==================================================================================
基本数据类型常用功能：
1、整数，int
    a.
        n1 = 123
        n2 = 456
        print(n1 + n2)
        
        print(n1.__add__(n2))

    b.
        获取可表示的二进制最短位数

        n1 = 4          #000000100
        ret = n1.bit_length()
        print(ret)    #返回结果 3


2、字符串，str

    2.1.capitalize 首字母大写：
        a1 = "alex"
        ret = a1.capitalize()
        print (ret)
Alex

    2.2 center 字符串长度增加为20，a1居中，空白处用*填充
        a1 = "alex"
        ret = a1.center(20,'*')
        print (ret)
********alex********

    2.3 count 查找字符串中子序列的个数
        a1 = "alex is alph"
        ret = a1.count("al")
        print (ret)
2

    查找字符串指定段中子序列的个数
        a1 = "alex is alph"
        ret = a1.count('al',0,5)
        print (ret)
1

    2.4 endswith 是否是以……结尾的
        temp = 'hello'
        print (temp.endswith("lo"))
True

    指定某段子序列是否是以……结尾的
        temp = 'hello'
        print (temp.endswith('e', 0, 2))
True

    startwith 是否是以……开始的
        temp = 'hello'
        print (temp.startswith("he"))        
True
        
        temp = 'hello'
        print (temp.startswith("ll", 2))
True

    2.5 expandtabs   tab键换成空格，默认换成8个空格
        content = "hello\t999"
        print(content)
        print (content.expandtabs())
        print (content.expandtabs(20))

    2.6 find 找在字符串中的第一个位置，返回位置，如果没找到返回-1，默认从左向右找

        s = "alex hello"
        print (s.find("e0"))
-1

        s = "alex hello"
        print (s.find("e"))
2

    rfind 从右向左找
        s = "Alex sb alex"
        print (s.rfind('e'))
10


    2.7 format 字符串格式化
        s = "hello {0}, age {1}"
        print (s)
        # {0} 占位符
        new1 = s.format('alex', 18)
        print (new1)
hello {0}, age {1}
hello alex, age 18

    2.8 index 寻找子序列的位置，如果没找到，报错，默认从左向右找
        s = "alex hello"
        print (s.index("eo"))
报错
        s = "alex hello"
        print (s.index("e"))
2

    rindex 从右向左找
        s = "alex hello"
        print (s.rindex("e"))
6

    2.9 isalnum 是否全是字母和数字
        s = "alex9"
        print (s.isalnum())

    isalpha 是否全是字母
        s = "alex9"
        print (s.isalpha())

    isdigit 是否全是数字
        s = "9999"
        print (s.isdigit())
True

    islower 是否全是小写
        s = "alex9"
        print (s.islower())

    isspace 是否是空格
        s = " alex9 "
        print (s.isspace())
False

    istitle 是否是标题，所有单词首字母大写
        s = "The School"
        print (s.istitle())
True


    isupper 是否全部大写
        s = "The School"
        print (s.isupper())


    2.9 join 连接
        #li = ["alex", "eric", "alice"] #列表
        li = （"alex", "eric", "alice"）#元组
        s = "_".join(li)
        print (s)
alex_eric_alice

    2.10 ljust 内容左对齐，右侧填充
        s = "alex"
        print (s.ljust(10, '*'))
alex******

    rjust 内容右对齐，左侧填充
        s = "alex hello"
        print (s.rjust(20, '*'))
**********alex hello

    2.11 lower 字符串变小写
        s = "Alex"
        print (s.lower())
alex

    2.12 strip 去掉左右两头的空格
        s = " Alex  "
        print (s.strip())
Alex

    lstrip 去掉左边的空格
        s = " Alex  "
        print (s.lstrip())
Alex  


    rstrip 去掉右边的空格
        s = " Alex  "
        print (s.rstrip())
 Alex

    2.13 partition 把字符串分割，放入元组里面，默认从左向

右找
        s = "Alex sb alex"
        print (s.partition('sb'))
('Alex ', 'sb', ' alex')

        s = "Alex sb alex"
        print (s.partition('e'))
('Al', 'e', 'x sb alex')

    rpartition 从右向左找
        s = "Alex sb alex"
        print (s.rpartition('e'))
('Alex sb al', 'e', 'x')


    2.14 replace 替换
        s = "Alex sb alex"
        print (s.replace('a', 'tb'))
Alex sb tblex

        s = "Alex sb alex"
        print (s.replace('e', 'tb'))
Altbx sb altbx

        s = "Alex sb alex"
        print (s.replace('e', 'tb', 1))
Altbx sb alex

        s = "Alex sb alex"
        print (s.replace('e', 'tb', 2))
Altbx sb altbx

    2.15 split 分割，默认从左向右
        s = "alexalex"
        print (s.split('e'))
['al', 'xal', 'x']

        s = "alexalex"
        print (s.split('e',1))
['al', 'xalex']

    rsplit 从右向左
        s = "alexalex"
        print (s.rsplit('e',1))
['alexal', 'x']

    splitlines根据换行符分割，\t 制表符（tab键） \n 换行

符
        s = "alex\nalex"
        print (s.splitlines())
['alex', 'alex']

    2.16 swapcase 小写变大写 大写变小写
        temp = 'Hello'
        print (temp.swapcase())
hELLO

    2.17 title 变成标题，所有单词首字母大写
        temp = 'the school'
        print (temp.istitle())
        print (temp.title())
False
The School

    upper 变大写
        temp = 'The school'
        print (temp.isupper())
        print (temp.upper())
False
THE SCHOOL


---------------------------

    2.20 字符串索引
        s = 'alex'
        #索引
        print (s[0])
        print (s[1])
        print (s[2])
        print (s[3])
        #print (s[4]) 报错，索引超出范围 IndexError:

string index out of range
        #长度
        ret = len(s)
        print (ret)
a
l
e
x
4

    2.21 切片
        s = 'alex'
        print(s[0:2])
al

    2.22 while循环
        s = "alibaba"
            start = 0
        while start < len(s):
                temp = s[start]
                print (temp)
                start +=1
a
l
i
b
a
b
a

    2.23 for循环
        s = "buffer"
        for item in s:
                print (item)
b
u
f
f
e
r

        s = "buffer"
        for item in s:
                if item == 'f':
                    continue
                print (item)
b
u
e
r


        s = "buffer"
        for item in s:
                if item == 'f':
                    break
                print (item)
b
u

=============================================================

=======================
3、列表 list

name_list = ["alex", "tony", "alice"]
#索引
# print (name_list[2])
# #切片
# print (name_list[0:2])
# #len
# print (name_list[0:len(name_list)])
# #for
# for i in name_list:
#     print (i)

#列表内部提供的其它功能
#append 追加，在后面追加
# name_list.append("seven")
# print (name_list)
# print (name_list.count("seven"))

#extend 批量追加  iterable 可迭代的
temp = [11, 22, 33]
name_list.extend(temp)
print (name_list)
#index 从左向右找 索引 第几个
print (name_list.index('alice'))
#insert 从左向右 插入
name_list.insert(2,'samsung')
name_list.insert(2,'samsung')
name_list.insert(2,'samsung')
print (name_list)
# pop 移除最后一个 赋值
n1 = name_list.pop()
print (name_list)
print (n1)
#remove移除 移除了从左向右数第一个samsung
name_list.remove("samsung")
print (name_list)
# reverse 反转 数据顺序反转
name_list.reverse()
print (name_list)

#删除指定索引位置
name_list = ["alex", "tony","king", "love", "alice"]
del name_list[1:3]
print (name_list)


=============================================================

=======================
4、元组 tuple 同列表，不同之处是元组不能修改

name_tuple = ("alex", "alice")
#索引
print (name_tuple[0])
#len
print (name_tuple[len(name_tuple)-1])
#切片
print (name_tuple[0:2])
# for
for i in name_tuple:
    print (i)

#count 计算元素出现的个数
print (name_tuple.count("alex"))

#index 获取指定元素的索引位置
print (name_tuple.index("alex"))

=============================================================

=======================
5、字典 dict
#字典的每个元素，都是一 键值对

usr_info = {
    "name": "alex",
    "age": 18,
    "gender": "M"
}

#索引
# print (usr_info['name'])

# #循环 默认输出key
# for i in usr_info:
#     print (i)
# #获取所有key
# print (usr_info.keys())
# #获取所有value
# print (usr_info.values())
# #获取所有键值对
# print (usr_info.items())

# for i in usr_info.keys():
#     print (i)
#
# for i in usr_info.values():
#     print (i)
#把key赋值给i，把value赋值给k
# for i, k in usr_info.items():
#     print (i)
#     print (k)

#clear，清除所有内容
# usr_info.clear()
# print (usr_info)

#get 根据key获取值，如果key不存在，返回None，不报错，可以给它

指定一个默认值
# val = usr_info.get("age")
# print (val)
#
# val = usr_info.get("age111", '123')
# print (val)

# #索引取值时，如果key不存在，报错
# print (usr_info['age'])
# print (usr_info['age333'])

#has_key 检查字典中指定key是否存在
# usr_info.has_key('age')  python3里没有这个函数了
#用in 代替has_key
# ret = 'age' in usr_info.keys()
# print (ret)

#update 更新
# print (usr_info)
# test = {
#     "a1": 123,
#     "a2": 456
# }
# usr_info.update(test)
# print (usr_info)

#pop 获取并在字典中移除指定的键值
# print (usr_info)
# a1 = usr_info.pop("gender")
# print (usr_info)
# print (a1)

#popitem 获取并移除字典尾部键值对
# print (usr_info)
# a1 = usr_info.popitem()
# print (usr_info)
# print (a1)

#setdefault 如果key不存在，则创建，如果存在，则返回已存在的值

且不修改
# print (usr_info)
# usr_info.setdefault("age1", 33)
# print (usr_info)

#del 删除
print (usr_info)
del usr_info['age']
print (usr_info)


#enumerate 自动生成一列，默认0开始 自增1
#字符串=> 数字 int（字符串）
    li = ['电脑', '鼠标', 'U盘', '游艇']
    for key, item in enumerate (li, 1):
            print (key, item)

    inp = input('请输入商品：')
    inp_num = int(inp)
    print (li[inp_num - 1])
1 电脑
2 鼠标
3 U盘
4 游艇
请输入商品：3
U盘


# range xrange
# py 2.7
#range, 用来获取指定范围内的数，range(0, 100000)
# 在内存里立马全部创建出来
#xrange, 用来获取指定范围内的数，xrange(0, 100000)
# 在内存里不创建，只有通过for循环迭代它的时候才创建

# py 3 只有range，等同于2.7里面的xrange
# print (range(0, 10))
# for i in range(0, 10, 3):
#     print (i)

# print (range(10, 1))
# for i in range(10, 1, -2):
#     print (i)

li = ["alex", "alice"]
le = len(li)

for i in range(0, le):
    print (i, li[i])