zoukankan      html  css  js  c++  java

  • Learn_Day2 运算符、基本数据类型

    1、编码补充
         2.7版本
              utf-8 ==>> gbk
              utf-8解码nuicode编码gbk
    1 temp = "李杰"  # utf-8
2 # 解码,需要解释原来所用编码
3 temp_unicod = temp.decode('utf-8')
4 temp_gbk = temp_unicod.encode("gbk")
5 print(temp_gbk)
    编码2.7

          3.5版本

              utf-8编码成gbk
         windows上输出：utf－8 ==>> unicode 
    1 temp = "李杰"
2 temp_gbk = temp.encode("gbk")
3 print(temp_gbk)
4 #b'xc0xeexbdxdc'
    编码3.5
    2、PyCharm全局配置（Mac）
    PyCharm==>Editor==>Preferences==>File and Code Templates==>Python Script
    3、运行：右键 Run
    4、切换版本：
    PyCharm==>Preferences==>Project:文件夹名==>Project Interpreter
    5、运算符
    　　- 算术运算符
      • 加  ＋  两个对象相加 
        1 n1 = 123
2 n2 = 456
3 print(n1+n2)  # 579
4 print(n1.__add__(n2))  # 579
        1 a = 21
2 b = 10
3 c = 0
4 
5 c = a + b
6 print("1 - c 的值为：", c)  # 1 - c 的值为： 31
        加　　　　　　
      •  减  —  得到负数或是一个数减去另一个数 
        1 a = 21 
2 b = 10 
3 c = 0 
4 c = a - b 
5 print("2 - c 的值为：", c) # 2 - c 的值为： 11
        减
      • 乘  ＊  两个对象相乘或是返回一个被重复若干次的字符串 
        1 a = 21
2 b = 10
3 c = 0
4 c = a * b
5 print("3 - c 的值为：", c) # 3 - c 的值为： 210
        乘
      • 除  ／  x除以y 
        1 a = 21
2 b = 10
3 c = 0
4 c = a / b 
5 print("4 - c 的值为：", c) # 4 - c 的值为： 2.1
        除
        1 # 2.7中计算除法需要引用(不引用只能得到整数) 
2 from __future__ import division 3 a = 9 / 2 4 print(a) # 4
3 
4 # 3.5中除法不需要引用
5 b = 9 / 2 3 print(b) # 4.5
        3.7与3.5的区别
      • 取膜  ％  返回除法的余数 
        1 a = 21
2 b = 10
3 c = 0
4 c = a % b 
5 print("5 - c 的值为：", c) # 5 - c 的值为： 1
        取膜

      • 幂  ＊＊  返回x的y的次幂

        a = 2 
b = 3
c = a**b 
print("6 - c 的值为：", c) # 6 - c 的值为： 8
        幂

      • 取整除  ／／  返回商的整数部分 

        1 a = 10 
2 b = 5 
3 c = a//b 
4 print("7 - c 的值为：", c) # 7 - c 的值为： 2
        取整除

    　　-比较运算符

      • 等于  ＝＝  比较对象是否相等(a == b)返回False。 
        1 a = 21
2 b = 10
3 c = 0
4 
5 if a == b:  # 1 - a 不等于 b
6     print("1 - a 等于 b")
7 else:
8     print("1 - a 不等于 b”)
        等于
      • 不等于  !=  比较两个对象是否不相等(a != b)返回true. 
        1 a = 21
2 b = 10
3 c = 0
4 
5 if a != b:  # 2 - a 不等于 b
6     print("2 - a 不等于 b")
7 else:
8     print("2 - a 等于 b”)
        不等于
      • 不等于  <>  比较两个对象是否不相等(a <> b)返回true。这个运算符类似!=。 
        1 a = 21
2 b = 10
3 c = 0
4 
5 if a <> b:  # 3 - a 不等于 b
6     print("3 - a 不等于 b")
7 else:
8     print("3 - a 等于 b")
        不等于
      • 大于  >  返回x是否大于y(a > b)返回False。 
        1 a = 21
2 b = 10
3 c = 0
4 
5 if a > b:  # 5 - a 大于 b
6     print("5 - a 大于 b")
7 else:
8     print("5 - a 小于等于 b")
        大于
      • 小于  <  返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。(a < b)返回true。 
        1 a = 21
2 b = 10
3 c = 0
4 if a < b:  # 4 - a 大于等于 b
5     print("4 - a 小于 b")
6 else:
7     print("4 - a 大于等于 b")
        小于
      • 大于等于  >=  返回x是否大于等于y。(a >= b)返回False。 
        1 a = 5;
2 b = 20;
3 if a <= b:  # 6 - a 小于等于 b
4     print("6 - a 小于等于 b")
5 else:
6     print("6 - a 大于  b")
        大于等于
      • 小于等于  <=  返回x是否小于等于y。 
        1 a = 5;
2 b = 20;
3 if b >= a:  # 7 - b 大于等于 b
4     print("7 - b 大于等于 b")
5 else:
6     print("7 - b 小于 b")
        小于等于

    　　-赋值运算符

    ＝

    简单的赋值运算符

    c = a + b 将 a + b 的运算结果赋值为 c

    +=

    加法赋值运算符

    c＋＝a等效于c＝c＋a

    －＝

    减法赋值运算符

    c－＝a等效于c＝c－a

    ＊＝

    乘法赋值运算符

    c *= a 等效于 c = c * a

    /=

    除法赋值运算符

    c /= a 等效于 c = c / a

    %=

    取模赋值运算符

    c %= a 等效于 c = c % a

    **=

    幂赋值运算符

    c **= a 等效于 c = c ** a

    //=

    取整除赋值运算符

    c //= a 等效于 c = c // a

    　　

    　

    　-位运算符

    &

    按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0

    (a & b) 输出结果 12 ，二进制解释： 0000 1100

    |

    按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。

    (a | b) 输出结果 61 ，二进制解释： 0011 1101

    ^

    按位异或运算符：当两对应的二进位相异时，结果为1

    (a ^ b) 输出结果 49 ，二进制解释： 0011 0001

    ~

    按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1

    (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。

    <<

    左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。

    a << 2 输出结果 240 ，二进制解释： 1111 0000

    >>

    右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数

    a >> 2 输出结果 15 ，二进制解释： 0000 1111

     　　

    　　-逻辑运算符

    and

    x and y

    布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。

    (a and b) 返回 20。

    or

    a or y

    布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。

    (a or b) 返回 10。

    not

    not x

    布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

    not(a and b) 返回 False

       　　 

    　　

     

     

     

     

     

    -成员运算符

    in

    not(a and b) 返回 False

    x 在 y 序列中 , 如果 x 在 y 序列中返回 True。

    not in

    如果在指定的序列中没有找到值返回 True，否则返回 False。

    x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

    		 
    # 2.7
a = "ren hang"
b = "ren" in a
c = "aaa" in a
print(b,c)  # True False
# 粒度不同
# 3.5
li = ["alex","abc","eric"]
d = "alex" in li
e = "al" in li
print(d,e) # True False

    　　-身份运算符

    is

    is是判断两个标识符是不是引用自一个对象

    x is y, 如果 id(x) 等于 id(y) , is 返回结果 1

    not is

    is not是判断两个标识符是不是引用自不同对象

    x is not y, 如果 id(x) 不等于 id(y). is not 返回结果 1

     

     

     

    　　

    　　-运算符优先级

    >> <<

    右移，左移运算符

    &

    位 'AND'

    ^ |

    位运算符

    <= < > >=

    比较运算符

    <> == !=

    等于运算符

    = %= /= //= -= += *= **=

    赋值运算符

    is  is not

    身份运算符

    in  not in

    成员运算符

    not  or  and
    逻辑运算符
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
    6、基本数据类型
         数字  int
         字符串  str
         布尔值  bool
         列表  list
         元组  tuple
         字典  dict
    所有的字符串、数字、字典所具备的方法都存在相对应的“值”里
         所有对象所具备的功能都存在相应的类
    7、查看对象的类或对象所具备的功能（# 直接点击:鼠标直接放在要查询的功能上,(MAC版)command+左键,直接定位到功能处）
         1.str，ctr＋鼠标左键，找到str类内部所有的方法
         2.type 
    temp = "hey"
t = type(temp)  # 数据类型
print(t)  # <class 'str'>
         3.dir 
    1 temp = "Alex"
2 t = dir(temp)  # 获取数据类型
3 print(t)  # <获取  '>
         4.help，type 
    t = help(type(temp))
print(t)
         注意：对象或类的功能后括号内为参数，括号内是self表示不传参数，参数用逗号分隔，self后有几个表示可以传几个参数，参数后有“＝”表示有默认值，可以不传参数
    8、基本数据类型的常用功能
        • 整数 int
          • bit_length 表示二进制最少可以占几位 
            1 n1 = 4
2 print(n1.bit_length())  # 3
3 # bit_length 表示二进制最少可以占几位
        • 字符串 str：
          • capitalize 首字母大写 
            1 a = "ren hang"
2 ret = a.capitalize()
3 print(ret)
4 ＃ Ren hang
          • center(self,width,fillchar=None)  内容居中,width总长度，fillchar空白处填充内容：默认无 
            1 a = "ren hang"
2 ret = a.center(20, "*")
3 print(ret)
4 ＃ ******ren hang******
          • count 计数 
            a = "alex ren gill"
b = a.count("l")
print(b)
# 3
          • decode 解码 
            #2.7
temp = "李杰"  # utf-8
# 解码,需要解释原来所用编码
temp_unicod = temp.decode('utf-8')
# 编码
temp_gbk = temp_unicod.encode("gbk")
print(temp_gbk)
          • encode 编码：针对unicode 
            1 temp = "李杰"
2 temp_gbk = temp.encode("gbk")
3 print(temp_gbk)
          • endwith 以＊＊＊结尾 
            1 a = "alex"
2 b = a.endswith("x")
3 print(b)
4 ＃ True
          • expandtabs 讲tab键转换成8个空格： 表示tab键 
            1 a = "ren	hang"
2 b = a.expandtabs()
3 b2 = a.expandtabs(20)
4 print(b, b2)
5 ＃ ren     hang ren                 hang
          • find 找到子序列位置，找不到返回－1 
            1 a = "ren hang"
2 b = a.find("a")
3 b2 = a.index("n")
4 print(b, b2)
5 ＃ 5 2
          • format 字符格式化 
            a = "hello {0}, age {1}"
b = a.format("alex", 26)
print(b)
＃ hello alex, age 26
          • index 找到子序列位置，找不到报错（功能与find一样，忽略）
          • isalnum 字符串包含字母或数字 
            1 a1 = "renhang0214"
2 a2 = "renhang"
3 b1 = a1.isalnum()
4 b2 = a2.isalnum()
5 print(b1, b2)
6 ＃ True True
          • isalpha 字符串包只含字母 
            1 a1 = "renhang0214"
2 a2 = "renhang"
3 b1 = a1.isalpha()
4 b2 = a2.isalpha()
5 print(b1, b2)
6 ＃ False True
          • isdigit 字符串只包含数字 
            1 a1 = "renhang0214"
2 a2 = "1234"
3 b1 = a1.isdigit()
4 b2 = a2.isdigit()
5 print(b1, b2)
6 ＃ False True
          • islower 字符串中字母是否小写 
            1 a1 = "renhang0214"
2 a2 = "1234"
3 b1 = a1.islower()
4 b2 = a2.islower()
5 print(b1, b2)
6 ＃ True False
          • istitle 字符串是否为标题（所有首字母都大写） 
            a1 = "Ren Hang"
a2 = "ren Hang"
b1 = a1.istitle()
b2 = a2.istitle()
print(b1, b2)
＃ True False
          • isspace 判断是否为空格 
            1 a1 = "ren hang"
2 a2 = "renhang"
3 a3 = " "
4 b1 = a1.isspace()
5 b1 = a2.isspace()
6 b3 = a3.isspace()
7 print(b1, b2, b3)
8 ＃ False False True
          • isupper 字符串是否全部大写 
            1 a1 = "Ren Hang"
2 a2 = "REN HANG"
3 b1 = a1.isupper()
4 b2 = a2.isupper()
5 print(b1, b2)
6 ＃ False True
          • join(self,iterable) 连接 
            1 a = ["abc", "alex"]
2 b = "_".join(a)
3 print(b)
4 ＃ abc_alex
          • ljust 内容左侧对齐，从右侧开始填充 
            a = "Grissom
b = a.ljust(15, "=")
print(b)
＃ Grissom========
          • lower 转换成小写 
            1 a = "REN"
2 b = a.lower()
3 print(b)
4 ＃ ren
          • lstrip 移除左侧空白 
            1 a = "      Grissom"
2 b = a.lstrip()
3 print(b)
4 ＃ Grissom
          • partition 分隔成前，中后三部分，括号内为中间部分 
            1 a = "gissom 123 ren hang"
2 b = a.partition("123")
3 print(b)
4 ＃ ('gissom ', '123', ' ren hang')
          • replace 替换 
            1 a = "gissom 123 ren hang"
2 b = a.replace("g", "G", 1)
3 print(b)
4 ＃ Gissom 123 ren hang
          • rfind 从右向左找到子序列位置，找不到返回－1，使用方法与find一样
          • rindex 从右向左找到子序列位置，找不到报错，使用方法与index一样
          • rsplit 从左侧分割 
            1 a = "gissom gil ren hang"
2 b1 = a.rsplit("g")
3 b2 = a.rsplit("g", 2)
4 print(b1, b2)
5 ＃ ['', 'issom ', 'il ren han', ''] ['gissom ', 'il ren han', '']
          • rstrip 移除右侧空白 
            1 a = "gissom gil ren hang  "
2 b = a.rstrip()
3 print(b)
4 ＃ gissom gil ren hang
          • split 从右侧分割 
            a = "gissom gil ren hang"
b = a.split("g")
print(b)
＃ ['', 'issom ', 'il ren han', '  ']
          • spiltlines 按换行符分割 
            1 a = "gil
gissom"
2 b = a.splitlines()
3 print(b)
4 ＃ ['gil', 'gissom']
          • starwith 以＊＊开头 
            1 a = "gissom"
2 b = a.startswith("g")
3 print(b)
4 ＃ True
          • strip 移除两端空白 
            1 a = "  gissom  "
2 b = a.strip()
3 print(b)
4 ＃ gissom
          • swapcse 大小写转换 
            1 a = "gISSOm"
2 b = a.swapcase()
3 print(b)
4 ＃ GissoM
          • title 把字符串变成标题 
            1 a = "gissom"
2 b = a.title()
3 print(b)
4 ＃ Gissom
          • upper 转换成大写 
            a = "gissom"
b = a.upper()
print(b)
＃ GISSOM
          • zfill 返回指定的字符串，原字符串右对齐，左侧填充 
            1 a = "grissom"
2 b = a.zfill(20)
3 print(b)
4 ＃ 0000000000000grissom
          • 切片 
            a = "grissom"
b = a[0:2]
print(b)
＃ gr
          • len 字符串长度 
            1 a = "gissom 123"
2 b = len(a)
3 print(b)
4 ＃ 10
          • 循环 
             1 a = "grissom"
 2 # while 循环
 3 star = 0
 4 while star < len(a):
 5     temp = a[star]
 6     print(temp)
 7     star += 1
 8 """
 9 g
10 r
11 i
12 s
13 s
14 o
15 m
16 """
17 
18 # for 循环
19 for item in a:
20     print(item)
21 """
22 g
23 r
24 i
25 s
26 s
27 o
28 m
29 """
30 
31 for item in a:
32     if item == "s":
33         continue
34     print(item)
35 """
36 g
37 r
38 i
39 o
40 m
41 """
42 
43 for item in a:
44     if item == "s":
45         break
46     print(item)
47 """
48 g
49 r
50 i
51 """
            循环while，for
      • 　　列表list 
         1 name_list = ["alex", "eric", "gill"]
 2 print(name_list)
 3 # 索引
 4 print(name_list[0])
 5 # 切片
 6 print(name_list[0:2])
 7 # len
 8 print(name_list[2:len(name_list)])
 9 # for
10 for i in name_list:
        列表# 索引# 切片# len# f
          • append 追加 
            1 name_list = ["alex", "eric", "gill"]
2 name_list.append("R")
3 print(name_list)
4 ＃ ['alex', 'eric', 'gill', 'R']
          • count 统计个数 
            name_list = ["alex", "eric", "gill"]
b = name_list.count("alex")
print(b)
＃ 1
          • extend 扩展　 
            1 name_list = ["alex", "eric", "gill", "R"]
2 temp =[11,22,33]
3 name_list.extend(temp)
4 print(name_list)
5 ＃ ['alex', 'eric', 'gill', 'R', 11, 22, 33]
          • index 索引　　 
            1 name_list = ["alex", "eric", "gill", "R", 11, 22, 33]
2 b = name_list.index("alex")
3 print(b)
4 ＃ 0
          • insert 插入　　 
            1 name_list = ["alex", "eric", "gill", "R", 11, 22, 33]
2 b = name_list.insert(2, "grissom")
3 print(name_list)
4 ＃ ['alex', 'eric', 'grissom', 'gill', 'R', 11, 22, 33]
          • pop 在原列表移除并赋值给其他变量（可仅移除） 
            name_list = ["alex", "eric", "grissom", "gill", "R", 11, 22, 33]
b = name_list.pop()
print(name_list)
print(b)
＃ ['alex', 'eric', 'grissom', 'gill', 'R', 11, 22]
＃ 33
          • remove 移除某个元素 
            1 name_list = ['alex', 'eric', 'grissom', 'gill', 'R', 11, 22] 
            2 name_list.remove(11) 
            3 print(name_list) 
            4 ＃ ['alex', 'eric', 'grissom', 'gill', 'R', 22]
          • reverse 反转 
            1 name_list = ["alex", "eric", "grissom", "gill", "R", 22]
2 name_list.remove(11)
3 print(name_list)
4 ＃ [22, 'R', 'gill', 'grissom', 'eric', 'alex']
          • del 删除 
            1 name_list = ["alex", "eric", "grissom", "gill", "R", 22]
2 # del 删除
3 del name_list[1]
4 print(name_list)
5 # [22, 'gill', 'grissom', 'eric', 'alex']
6 # del 删除指定索引位置
7 del name_list[1:3]
8 print(name_list)
9 # [22, 'eric', 'alex']
        • 元组 tuple
          • 元组与列表几乎一样； 列表可以进行修改，元组不可修改
          • 索引　　 
            1 name_tuple = ("alex", "eric")
2 print(name_tuple[0])
3 # alex
          • len 计算元组长度　　 
            name_tuple = ("alex", "eric")
print(name_tuple[len(name_tuple)-1])
# eric
          • 切片 
            1 name_tuple = ("alex", "eric")
2 print(name_tuple[0:1])
3 # ('alex',)
          • for循环 
            1 name_tuple = ("alex", "eric")
2 for i in name_tuple:
3     print(i)
4 """
5 alex
6 eric
7 """
          • 不支持del删除　　
          • count 计算元组个数　　 
            1 name_tuple = ("alex", "eric")
2 print(name_tuple.count("alex"))
3 # 1
          • index 获取指定元素的索引位置　 
            name_tuple = ("alex", "eric")
print(name_tuple.index("alex"))
# 0
        • 字典 dict
          • 字典的每一个元素都是键值对　　
          • 索引 通过key进行(取值时,key不存在,报错)　 
            1 user_info = {
2     "name": "alex",
3     "age": 20,
4     "gender": "M"
5 }
6 
7 print(user_info["name"])
8 # alex
          • 循环 默认输出所有key　 
             1 user_info = {
 2     "name": "alex",
 3     "age": 20,
 4     "gender": "M"
 5 }
 6 
 7 for i in user_info:
 8     print(i)
 9 """
10 age
11 name
12 gender
13 """
          • keys 键　　 
            1 user_info = {
2     "name": "alex",
3     "age": 20,
4     "gender": "M"
5 }
6 
7 print(user_info.keys())
8 # dict_keys(['age', 'name', 'gender'])
          • values 值　　 
            1 user_info = {
2     "name": "alex",
3     "age": 20,
4     "gender": "M"
5 }
6 
7 print(user_info.values())
8 # dict_values([20, 'alex', 'M'])
          • items 键值对　 
            user_info = {
     "name": "alex",
     "age": 20,
     "gender": "M"
 }
 
 print(user_info.items())
#   dict_items([('age', 20), ('name', 'alex'), ('gender', 'M')])
 for k,v in user_info.items():
     print(k,v)
 """
name alex
age 20
gender M
"""
          • get 根据key获取值,如果key不存在,可以指定一个默认值　　 
            user_info = {
    "name": "alex",
    "age": 20,
    "gender": "M"
}

val = user_info.get("name")
print(val)
# alex
val2 = user_info.get("user","gr")
print(val2)
# gr
          • has_key 检查字典中某个指定key是否存在《2.7版本》　　
          • pop 获取并在字典中移除（可指定key）　　
          • popitem 获取并在字典中移除（移除最后一个，不可指定key）　　
          • update 更新　　 
             1 user_info = {
 2     "name": "alex",
 3     "age": 20,
 4     "gender": "M"
 5 }
 6 
 7 t = {"a1": 123, "a2": 456}
 8 user_info.update(t)
 9 print(user_info)
10 # {'a2': 456, 'a1': 123, 'name': 'alex', 'age': 20, 'gender': 'M'}
          • del 删除　　 
            user_info = {
    "name": "alex",
    "age": 20,
    "gender": "M"
}

del user_info["a1"]
print(user_info)
# {'a2': 456, 'name': 'alex', 'age': 20, 'gender': 'M'}
          • clear 清除所有内容　　 
            1 user_info = {
2     "name": "alex",
3     "age": 20,
4     "gender": "M"
5 }
6 
7 user_info.clear()
8 print(user_info)
9 # {}
        • 补充：　　
          1. enumrate 为可迭代对象添加序号　　 
            1 li = [11, 22, 33]
2 for k, v in enumerate(li, 1):
3     print(k, v)
4 """
5 1 11
6 2 22
7 3 33
8 """
          2. range 3.0以上版本 用来获取指定范围内的数　 
            for i in range(1, 10):
    print(i)
    # 结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]

for i in range(1, 10, 2):
    print(i)
    # 结果：[1, 3, 5, 7, 9]

for i in range(30, 0, -2):
    print(i)
    # 结果：[30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2]
          3. xrange 2.7版本   用来获取指定范围内的数　　
        • 注意：只要能通过for循环操作的都是可迭代的　　
  • 相关阅读:
    实现路由的RouterMiddleware中间件
    AI: Jarvis
    使用管道（PipeLine）和批量（Batch）操作
    OSWatcher Black Box
    NET Core HTTP 管道
    开源项目！
    Router的创建者——RouteBuilder
    .NET Core）的ZooKeeper异步客户端
    single-write-database-connection
    Quartz与Spring集成 Job如何自动注入Spring容器托管的对象
  • 原文地址：https://www.cnblogs.com/grissom/p/5932406.html
Copyright © 2011-2022 走看看