Python学习记录day2-变量类型、运算符

末蓝、 2022-07-14 00:52 324阅读 0赞

今天，跟着Alex喝了心灵的鸡汤：Be a new gentlmen

  • 着装得体
  • 每天洗澡
  • 适当用香水
  • 女士优先
  • 不随地吐痰、不乱扔垃圾、不在人群中抽烟
  • 不大声喧哗
  • 不插队、碰到别人要说抱歉
  • 不在地铁上吃东西
  • 尊重别人的职业和劳动
  • 尊重别人隐私，不随便打听别人工资

  • 与人保持安全距离（1米）

  • 多去旅行，一年至少一个国家

  • 多看书，电影，一年15本书，50+部电影
  • 学好英语
  • 保持不甘心、保持正能量
  • 做事件一定要学会换位思考，要想此事会不会给别人造成不好的困扰
  • 积极影响身边的人

推荐读书

  • 《三体》
  • 《百年孤独》

常量：用全部大写字母命名变量名

引入模块：

  1. import os  #推荐一行一个

安装模块： 

  1. pip install pandas

os模块执行系统命令：

  1. os.system("df")
  2. os.popen("ifconfig").read()

.pyc是什么？

Python是一门基于虚拟机的语言，pyc 是由py文件经过编译后二进制文件，py文件变成pyc文件后，加载的速度有所提高，而且pyc是一种跨平台的字节码，是由python 的虚 拟机来执行的。

数据类型

1.数字

int（整型）

32位系统：-2**31-1~2**31-1

64位系统：-2**63-1~2**63-1

type()函数用于输出数据类型

long（长整型）

float（浮点型）

2.布尔值

真或假

1或0

3.字符串

推荐使用格式化输出：

  1. Y = "test"
  2. str  = "This is a %s" %Y
  3. print (str)

PS：字符串是%s；整数是%d；浮点数是%f

+号拼接字符串，效率低，因为其使用了多块内存空间。

字符串

字符串常用功能

  • 移除空白
  • 分割
  • 索引
  • 切片
  • 长度

字符串操作

删除空格

  1. >>> name="abc  "
  2. >>> name=name.strip()
  3. >>> name
  4. 'abc'

分割字符串

  1. >>> user="jim|jack"
  2. >>> print(user.split("|"))
  3. ['jim', 'jack']

判断是否有空格

  1. >>> name="jim jack"
  2. >>> print(' ' in name)
  3. True

首字母大写

  1. >>> print(name.capitalize())
  2. Jim jack

格式化输出字符串

  1. >>> msg = "Hello, {name}, I am fine"
  2. >>> msg.format(name="Jimme")
  3. 'Hello, Jimme, I am fine'
  4. >>> msg2="hahaha{0}, dddd{1}"
  5. >>> print(msg2.format('Ini',33))
  6. hahahaIni, dddd33

切片

  1. >>> name="This is a test1,and what's your name"
  2. >>> print(name[2:7])
  3. is is

查找

  1. >>> print(name.find('test'))
  2. 10
  3. >>> print(name.find('tTTTT'))
  4. -1

按长度填充字符串

  1. >>> print(name.center(40,'x')
  2. ... )
  3. xxThis is a test1,and what's your namexx

字符串是否为数字

  1. >>> age="27"
  2. >>> print(age.isdigit())
  3. True

字符串是否包含数字、开头、结局是否包含字符

  1. >>> name = "test01"
  2. >>> print(name.isalnum())
  3. True
  4. >>> print(name.endswith("df"))
  5. False
  6. >>> print(name.startswith("df"))
  7. False

字符串大小写转换

  1. >>> print(name.upper(),name.lower())
  2. TEST01 test01

列表

列表基本操作：

  • 索引
  • 切片
  • 追加
  • 删除
  • 长度
  • 切片
  • 循环
  • 包含

切片:取多个元素　　

  1. >>> name = ["abc","jack",1,2,3,4]
  2. >>> name[-3:-1]
  3. [2, 3]
  4. >>> name[-3:0]
  5. []
  6. >>> name[-3:]
  7. [2, 3, 4]
  8. >>> name[:1]
  9. ['abc']
  10. >>> name[:2]
  11. ['abc', 'jack']

切片后再切片

  1. >>> name[:2][:1][0]
  2. 'abc'
  3. >>> name[:2][:1][0][1]
  4. 'b'

修改列表元素

  1. >>> name[3]="xiaoming"
  2. >>> name
  3. ['abc', 'jack', 1, 'xiaoming', 3, 4]

插入

  1. >>> name.insert(2,"wangou")
  2. >>> name
  3. ['abc', 'jack', 'wangou', 1, 'xiaoming', 3, 4]

追加

  1. >>> name.append("mac")
  2. >>> name
  3. ['abc', 'jack', 'wangou', 1, 'xiaoming', 3, 4, 'mac']

删除

  1. >>> name.remove(3)
  2. >>> name
  3. ['abc', 'jack', 'wangou', 1, 'xiaoming', 4, 'mac']

删除是只删除一个

  1. >>> name.append("mac")
  2. >>> name
  3. ['abc', 'jack', 'wangou', 1, 'xiaoming', 4, 'mac', 'mac']
  4. >> name.remove("mac")
  5. >>> name
  6. ['abc', 'jack', 'wangou', 1, 'xiaoming', 4, 'mac']
  7. >>> print(name[::2])
  8. ['abc', 'wangou', 'xiaoming', 'mac']

元素是否在列表中，查找元素个数，查找元素位置

  1. >>> name
  2. ['abc', 'jack', 'wangou', 1, 'xiaoming', 4, 'mac']
  3. >>> print(1 in name)
  4. True
  5. >>> print(name.count(4))
  6. 1
  7. >>> print(name.index(4))
  8. 5

扩展（合并列表）

  1. >>> name2=["zhangzi","lizi","wangba"]
  2. >>> name.extend(name2)
  3. >>> print(name)
  4. ['abc', 'jack', 'wangou', 1, 'xiaoming', 4, 'mac', 'zhangzi', 'lizi', 'wangba']

反序排列元素

  1. >>> name.reverse()
  2. >>> print(name)
  3. ['wangba', 'lizi', 'zhangzi', 'mac', 4, 'xiaoming', 1, 'wangou', 'jack', 'abc']

元素排序（版本3不支持字符与数字排序）

  1. >>> name.sort()
  2. Traceback (most recent call last):
  3.   File "<stdin>", line 1, in <module>
  4. TypeError: unorderable types: int() < str()
  5. >>> name
  6. ['lizi', 'mac', 'wangba', 'zhangzi', 4, 'xiaoming', 1, 'wangou', 'jack', 'abc']
  7. >>> name=[1,3,2,4]
  8. >>> name.sort()
  9. >>> print(name)
  10. [1, 2, 3, 4]

移除元素（默认移除最后一个元素）

  1. >>> name.pop()
  2. 4
  3. >>> print(name)
  4. [1, 2, 3]

移除指定元素

  1. >>> name.pop(1)
  2. 2
  3. >>> print(name)
  4. [1, 3]

拷贝

  1. >>> name3 = name.copy()
  2. >>> print(name3)
  3. [1, 3]

拷贝时，第一层的元素（非列表）不会改变，元素为列表时与变量赋值一样，内存地址不变，所以2个列表内，元素为列表内的元素变化时，2个列表也一起改变

  1. >>> name=[1,2,3,[1,2,3,4],4]
  2. >>> name2 = name.copy()
  3. >>> name2
  4. [1, 2, 3, [1, 2, 3, 4], 4]
  5. >>> name[3][2]="TTT"
  6. >>> name
  7. [1, 2, 3, [1, 2, 'TTT', 4], 4]
  8. >>> name2
  9. [1, 2, 3, [1, 2, 'TTT', 4], 4]
  10. >>> name[2]="AAA"
  11. >>> name
  12. [1, 2, 'AAA', [1, 2, 'TTT', 4], 4]
  13. >>> name2
  14. [1, 2, 3, [1, 2, 'TTT', 4], 4]

删除列表

  1. >>> del name2
  2. >>> name2
  3. Traceback (most recent call last):
  4.   File "<stdin>", line 1, in <module>
  5. NameError: name 'name2' is not defined

元组：不能被修改

基本操作：

  • 索引
  • 切片
  • 循环
  • 长度

  • 包含

    r=(1,2,3,4,5)
    r
    (1, 2, 3, 4, 5)
    type(r)

    r[2]=1
    Traceback (most recent call last):
    File ““, line 1, in
    TypeError: ‘tuple’ object does not support item assignment

数据运算符

和其它语言一样，python也支持进行各种各样的数学和逻辑运算，我们一起来看一些。

python语言支持以下几种运算

算术运算

比较运算

Assignment Operators

二进制运算

关系运算

验证运算

算术运算












































运算符

描述

示例

+

加法运算

a + b 得 30

-

减法运算

a - b 得 -10

乘法运算

a b 得 200

/

除法运算

b / a 得 2

%

取模 - 将%号左边的值除以%号右边的值并且将得到的结果的余数返回

10%5得0 ，10%3 得1， 20%7 得6

幂 - 返回x的y次幂，就是返回多少次方

28 得256

//

取整除 - 返回x除以y的商的整数部分

9//2得4 ， 9.0//2.0得4.0

比较运算












































运算符

描述

示例

==

判断两个对象是否相等

(a == b) is not true.

!=

判断两个对象是否不相等

(a != b) is true.

<> 

判断两个对象是否不相等

(a <> b) is true. 与 != 运算符一样.

> 

大于 - 返回a是否大于b

(a > b) is not true.

< 

小于 - 返回a是否小于b

(a < b) is true.

>=

大于等于 - 返回a 是否大于等于b

(a >= b) is not true.

<=

小于等于 - 返回a 是否小于等于b

(a <= b) is true.

赋值运算

















































运算符

描述

示例

=

赋值 - 将右边的值赋值给左边的变量名

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

按位运算(二进制运算)
















































二进制位数

8

7

6

5

4

3

2

1

每位所代表的数字

128

64

32

16

8

4

2

1

60

0

0

1

1

1

1

0

0

13

0

0

0

0

1

1

0

1

2个10进制数字的位运算


































运算符

描述

示例

&

与运算，这个二进制位必须在2组数中都为真，结果才返回真

(a & b)得12，二进制位： 0000 1100

|

或运算，这个二进制位只需在其中一组数据中为真即返回真

(a | b)得 61，二进制位： 0011 1101

^

异或运算，只要这个二进制位在两组数据中不相同就返回真

(a ^ b)得 49 ，二进制位： 0011 0001

<< 

左移运算，将a整体向左移2位

a << 2得240，二进制位： 1111 0000

>> 

右移运算，将a整体向左移3位

a >> 3得 7 ，二进制位： 0000 0111

看下面的运算过程：
















































































































二进制位

8

7

6

5

4

3

2

1

结果

每位所代表的数字

128

64

32

16

8

4

2

1

  

60

0

0

1

1

1

1

0

0

  

13

0

0

0

0

1

1

0

1

  

&与运算

0

0

0

0

1

1

0

0

12

|或运算

0

0

1

1

1

1

0

1

61

^异或运算

0

0

1

1

0

0

0

1

49

a<<2

1

1

1

1

0

0

0

0

240

a>>3

0

0

0

0

0

1

1

1

7

逻辑运算符 and 、or 、not

关系运算符 in 、not in

验证运算符 is 、 is not

字典

  1. id_db = {
  2.     42342323232: {
  3.         'name': "Yangkun",
  4.         'age': 23,
  5.         'addr': 'Dongbei'
  6.     },
  7.     23232424224: {
  8.         'name': 'Guojin',
  9.         'age': 22,
  10.         'addr': 'Hubei'
  11.     }
  12. }

字典的特性：

  • dict是无序的
  • key必须是唯一的,so 天生去重

增加

  1. >>> id_db[322323232332]={
  2. ...     'name':'Guojia',
  3. ...     'age':45,
  4. ...     'addr':'Changan'
  5. ... }
  6. >>>
  7. >>> print(id_db)
  8. {42342323232: {'addr': 'Dongbei', 'age': 23, 'name': 'Yangkun'}, 23232424224: {'addr': 'Hubei', 'age': 22, 'name': 'Guojin'}, 322323232332: {'addr': 'Changan', 'age': 45, 'name': 'Guojia'}}

修改

  1. >>> id_db[23232424224]['age']=32
  2. >>> print(id_db)
  3. {42342323232: {'addr': 'Dongbei', 'age': 23, 'name': 'Yangkun'}, 23232424224: {'addr': 'Hubei', 'age': 32, 'name': 'Guojin'}, 322323232332: {'addr': 'Changan', 'age': 45, 'name': 'Guojia'}}

删除

  1. >>> id_db[23232424224].pop("addr")
  2. 'Hubei'
  3. >>> print(id_db)
  4. {42342323232: {'addr': 'Dongbei', 'age': 23, 'name': 'Yangkun'}, 23232424224: {'age': 32, 'name': 'Guojin'}, 322323232332: {'addr': 'Changan', 'age': 45, 'name': 'Guojia'}}

返回指定键的值，如果值不在字典中返回默认值

  1. >>> tmp = id_db.get(23232424224)
  2. >>> print(tmp)
  3. {'age': 32, 'name': 'Guojin'}

更新

  1. >>> dic2 = {
  2. ...     42342323232: {
  3. ...         'name': "Yangkun",
  4. ...         'age': 23,
  5. ...         'addr': 'Shangdong'
  6. ...     }
  7. ... }
  8. >>> id_db.update(dic2)
  9. >>> print(id_db)
  10. {42342323232: {'addr': 'Shangdong', 'age': 23, 'name': 'Yangkun'}, 23232424224: {'age': 32, 'name': 'Guojin'}, 322323232332: {'addr': 'Changan', 'age': 45, 'name': 'Guojia'}}

返回元组对的列表

  1. >>> print(id_db.items())
  2. dict_items([(42342323232, {'addr': 'Shangdong', 'age': 23, 'name': 'Yangkun'}), (23232424224, {'age': 32, 'name': 'Guojin'}), (322323232332, {'addr': 'Changan', 'age': 45, 'name': 'Guojia'})])

以列表返回字典中的所有值

  1. >>> print(id_db.values())
  2. dict_values([{'addr': 'Shangdong', 'age': 23, 'name': 'Yangkun'}, {'age': 32, 'name': 'Guojin'}, {'addr': 'Changan', 'age': 45, 'name': 'Guojia'}])

以列表返回一个字典所有的键

  1. >>> print(id_db.keys())
  2. dict_keys([42342323232, 23232424224, 322323232332])

key是否存在于字典中

  1. >>> 42342323232 in id_db
  2. True

get()方法类似, 如果键不已经存在于字典中，将会添加键并将值设为默认值

  1. >>> id_db.setdefault(42342323232)
  2. {'addr': 'Shangdong', 'age': 23, 'name': 'Yangkun'}
  3. >>> print(id_db)
  4. {42342323232: {'addr': 'Shangdong', 'age': 23, 'name': 'Yangkun'}, 23232424224: {'age': 32, 'name': 'Guojin'}, 322323232332: {'addr': 'Changan', 'age': 45, 'name': 'Guojia'}, 4: None}

用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值

  1. >>> print(dict.fromkeys([1,2,3,4,33,32],"TTTTEST"))
  2. {32: 'TTTTEST', 1: 'TTTTEST', 2: 'TTTTEST', 3: 'TTTTEST', 4: 'TTTTEST', 33: 'TTTTEST'}

随机删除一个元素

  1. >>> print(id_db.popitem())
  2. (42342323232, {'addr': 'Shangdong', 'age': 23, 'name': 'Yangkun'})
  3. >>> print(id_db)
  4. {23232424224: {'age': 32, 'name': 'Guojin'}, 322323232332: {'addr': 'Changan', 'age': 45, 'name': 'Guojia'}, 4: None}

循环字典（效率低，因为有一个dict to list的转换过程）

  1. >>> for k,v in id_db.items():
  2. ...     print(k,v)
  3. ...
  4. 23232424224 {'age': 32, 'name': 'Guojin'}
  5. 322323232332 {'addr': 'Changan', 'age': 45, 'name': 'Guojia'}
  6. 4 None
  8. >>> for key in id_db:   #效率高
  9. ...     print(key,id_db[key])
  10. ...
  11. 23232424224 {'age': 32, 'name': 'Guojin'}
  12. 322323232332 {'addr': 'Changan', 'age': 45, 'name': 'Guojia'}
  13. 4 None

本文出自 “ygqygq2” 博客，谢绝转载！

发表评论

表情：
评论列表 （有 0 条评论，324人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Python学习记录day5

    1.多层装饰器 多层装饰器的原理是，装饰器装饰函数后，其实也是一个函数，这样又可以被装饰器装饰。 编译是从下至上进行的，执行时是从上至下进行。 !/usr/bi

    清疚清疚/ 0 赞/ 364 阅读