Task1

print("hello world")

hello world

python学习笔记1

变量、运算符与数据类型

print ('A')

A

运算符

算术运算符

"""
+
-
*
/  float 结果为实数
//  ....取整
%   ....取余
**  ....幂
"""
#a为int ,b为float
a = 1
b = 2.0
c = a / b
print(c)

c = a // b
d = b // a
print(c,d)
type (c)

0.0 2.0

float

b = int(b)
c = a // b
print(c)

0

由上可知："//"，是取整，当"a // b"中，a,b均为整数时取整结果为整数int，当其中一个不为整数时，取整后的结果为实数float

print(a % b)#1%2
print(c%a)#0%1
print(b**c)#2**0

1
0
1

比较运算符

'''
>
>=
==
!=
'''
print(1>=5)

False

print(1==1)

True

print(1!=5)

True

逻辑运算符

''''
and       与
or        或
not       非
'''
print(1>=2 and 2<=4)
print(1>=2 or 2<=4)
print( not 1>=2)

False
True
True

短路，当and前面一个为错误时，自动停止不运行下一个，同理当or前面为正确时，也停止。

三元运算符

x, y = 4, 5
if x < y:
    small = x
else:
    small = y

print("最小值是",small)  

最小值是 4

上面代码用三元运算符表示为:

x,y = 4,5
small = x if x<y else y
print (small)

4

其他运算符

'''
in             存在
not in         不存在
is             是
not  is        不是

'''
letters = ['A', 'B', 'C']
if 'A' in letters:
    print('A' + ' exists')
if 'h' not in letters:
    print('h' + ' not exists')

A exists
h not exists

a = 1
b =1
print(a is b, a == b) 
print(a is not b, a != b) 

True True
False False

a = [1]
b = [1]
print(a is b, a == b)  # False True
print(a is not b, a != b)  # True False

False True
True False

Python中的中括号[]：

代表list列表数据类型

notice:

is, is not 对比的是两个变量的内存地址

==, != 对比的是两个变量的值

比较的两个变量，指向的都是地址不可变的类型（str等），那么is，is not 和 ==，！= 是完全等价的。

对比的两个变量，指向的是地址可变的类型（list，dict，tuple等），则两者是有区别的。

运算符的优先级

一元运算符优于二元运算符

print(2**-3)
print(2/-3)
print(2%-3)

0.125
-0.6666666666666666
-1

先算术运算，后移位运算，最后位运算

print(1 << 3 + 2 & 7)  

0

逻辑运算最后结合

print(3 > 4 and 4 < 5)

False

变量与变量类型

1、在使用变量之前，需要对其先赋值。动态—不用申明
2、变量名可以包括字母、数字、下划线、但变量名不能以数字开头。
3、Python 变量名是大小写敏感的，foo != Foo。有区别

数字型（基本类型变量）

整型(int)
浮点型(float)
布尔型(bool)

'''
int
'''
a = 1031
print(bin(a))  # bin(a) 把a用二进制表示  0b10000000111
print(a.bit_length())  # a.bit_length()返回a的长度
b = dir(int)
print(b)

0b10000000111
11
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']

'''
float
有时候我们想保留浮点型的小数点后 n 位。可以用 decimal 包里的 Decimal 对象和 getcontext() 方法来实现。
import decimal
from decimal import Decimal
Python 里面有很多用途广泛的包 (package)，用什么你就引进 (import) 什么。包也是对象，也可以用上面提到的dir(decimal) 来看其属性和方法。
'''

a = 0.00000023
b = 2.3e-7
print ("Decimal默认精度",decimal.getcontext())
print(a)
print(b)

Decimal默认精度 Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
2.3e-07
2.3e-07

#1/3表示成精度26位的小数
b = Decimal(1) / Decimal(3)
print(b)

0.3333333333333333333333333333

#使 1/3 保留 4 位，用 getcontext().prec 来调整精度。
decimal.getcontext().prec = 4
c = Decimal(1) / Decimal(3)
print(c)

0.3333

'''
bool
真 数学运算时表示1
假 数学运算时表示0
'''

a = False
b = True
print(a)
print(a*2)
print(b*2)

a == -1 

False
0
2





False

非数字型(容器类型变量)

字符串（"A"或’A’）(string)
** 列表(list)**
** 元组(tuple)**
字典 (dictionary)

变量之间的运算

1. 数字型变量之间直接计算

两个数字型可以直接计算,如果是布尔型在计算时True对应的数字是1 ,False对应的数字是0

'''
bool 作用在基本类型变量：X 只要不是整型 0、浮点型 0.0，bool(X) 就是 True，其余就是 False。
'''
print(bool(0), bool(0.0), bool(10.73))

False False True

'''
bool 作用在容器类型变量：X 只要不是空的变量，bool(X) 就是 True，其余就是 False。
'''
print(type(''), bool(''), bool('python'))
#  False True

print(type(()), bool(()), bool((10,)))
#  False True

print(type([]), bool([]), bool([1, 2]))
#  False True

print(type({}), bool({}), bool({'a': 1, 'b': 2}))
#  False True

print(type(set()), bool(set()), bool({1, 2}))
#  False True

 False True
 False True
 False True
 False True
 False True

上面type（）查看变量的类型, 例如 type(name) :查看变量name的类型
确定bool(X) 的值是 True 还是 False，就看 X 是不是空，空的话就是 False，不空的话就是 True。
注 ：
1、对于数值变量，0, 0.0 都可认为是空的。
2、对于容器变量，里面没元素就是空的。

2.字符串只能进行加法和乘法运算

a) 字符串之间用 + 拼接生成新的字符串

+在进行字符串拼接的时候,做的是运算符重载 ,在操作数不同的时候做的事情不一样,这里做的是拼接

a="ab"
b="cd"
c=a+b
print("结果是",c)

结果是 abcd

b) 字符串和整数的乘法运算

字符串和字符串之间不能进行 * 运算, 字符串和整除可以进行* 运算 , 字符串乘几就表示字符串重复拼接几次

a="ab"
c=a*3
print("结果是",c)

结果是 ababab

print() 函数

'''
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
'''

"\nprint(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)\n"

• 将对象以字符串表示的方式格式化输出到流文件对象file里。其中所有非关键字参数都按str()方式进行转换为字符串输出；
• 关键字参数sep是实现分隔符，比如多个参数输出时想要输出中间的分隔字符；
• 关键字参数end是输出结束时的字符，默认是换行符\n；
• 关键字参数file是定义流输出的文件，可以是标准的系统输出sys.stdout，也可以重定义为别的文件；
• 关键字参数flush是立即把内容输出到流文件，不作缓存。

eg01:没有参数时，每次输出后都会换行。

shoplist = ['apple', 'mango', 'carrot', 'banana']
print("This is printed without 'end'and 'sep'.")
for item in shoplist:
    print(item)

This is printed without 'end'and 'sep'.
apple
mango
carrot
banana

eg02:每次输出结束都用end设置的参数&结尾，并没有默认换行。

shoplist = ['apple', 'mango', 'carrot', 'banana']
print("This is printed with 'end='&''.")
for item in shoplist:
    print(item, end='&')
print('hello world')

This is printed with 'end='&''.
apple&mango&carrot&banana&hello world

eg03:item值与’another string’两个值之间用sep设置的参数&分割。由于end参数没有设置，因此默认是输出解释后换行，即end参数的默认值为\n。

shoplist = ['apple', 'mango', 'carrot', 'banana']
print("This is printed with 'sep='&''.")
for item in shoplist:
    print(item, 'another string', sep='&')

This is printed with 'sep='&''.
apple&another string
mango&another string
carrot&another string
banana&another string

练习题

1.怎样对python中的代码进行注释？

#行注释
‘’’ 或
‘’’
“”"
“”"
表示多行注释

2.python有哪些运算符，这些运算符的优先级是怎样的？

有算术运算符、逻辑运算符、比较运算符、位运算符、其他运算符、三元运算符
优先级：

• 一元运算符优于二元运算符。
• 先算术运算，后移位运算，最后位运算。
• 逻辑运算最后结合。

3.python 中 is, is not 与 ==, != 的区别是什么？

• is是变量地址相同；==是变量数值相等
• is not是变量地址不相同；==是变量数值不相等

4.python 中包含哪些数据类型？这些数据类型之间如何转换？

• 整型(int)
• 浮点型(float)
• 布尔型(bool)
• 字符串(string)
• 列表(list)
• 元组(tuple)
• 字典 (dictionary)
  如何转换：
  a = 1
  转成int:int(a)
  转成float:float(a)
  转成bool:bool(a)
  转成string:str(a)

位运算

1. 原码、反码和补码

二进制有三种不同的表示形式：原码、反码和补码，计算机内部使用补码来表示

原码：就是其二进制表示（注意，最高位是符号位）。

00 00 00 11 -> 3
10 00 00 11 -> -3

反码：正数的反码就是原码，负数的反码是符号位不变，其余位取反（对应正数按位取反）。

00 00 00 11 -> 3
11 11 11 00 -> -3

补码：正数的补码就是原码，负数的补码是反码+1。
00 00 00 11 -> 3
11 11 11 01 -> -3

符号位：最高位为符号位，0表示正数，1表示负数。在位运算中符号位也参与运算。

2. 按位非操作 ~

~ 1 = 0

0 = 1
~
把num的补码中的 0 和 1 全部取反（0 变为 1，1 变为 0）有符号整数的符号位在 ~ 运算中同样会取反。

00 00 01 01 -> 5
~
—
11 11 10 10 -> -6

11 11 10 11 -> -5
~
—
00 00 01 00 -> 4

3. 按位与操作 &

1 & 1 = 1
1 & 0 = 0
0 & 1 = 0
0 & 0 = 0
只有两个对应位都为 1 时才为 1

00 00 01 01 -> 5
&
00 00 01 10 -> 6
—
00 00 01 00 -> 4

4. 按位或操作 |

1 | 1 = 1
1 | 0 = 1
0 | 1 = 1
0 | 0 = 0
只要两个对应位中有一个 1 时就为 1

00 00 01 01 -> 5
|
00 00 01 10 -> 6
—
00 00 01 11 -> 7

5. 按位异或操作 ^

1 ^ 1 = 0
1 ^ 0 = 1
0 ^ 1 = 1
0 ^ 0 = 0
只有两个对应位不同时才为 1

00 00 01 01 -> 5
^
00 00 01 10 -> 6
—
00 00 00 11 -> 3
异或操作的性质：满足交换律和结合律

A: 00 00 11 00
B: 00 00 01 11

A^B: 00 00 10 11
B^A: 00 00 10 11

A^A: 00 00 00 00
A^0: 00 00 11 00

A^BA: = A^AB = B = 00 00 01 11

6. 按位左移操作 <<

num << i 将num的二进制表示向左移动i位所得的值。

00 00 10 11 -> 11
11 << 3
—
01 01 10 00 -> 88

7. 按位右移操作 >>

num >> i 将num的二进制表示向右移动i位所得的值。

00 00 10 11 -> 11
11 >> 2
—
00 00 00 10 -> 2

8. 利用位运算实现快速计算

通过 <<，>> 快速计算2的倍数问题。

n << 1 -> 计算 n2
n >> 1 -> 计算 n/2，负奇数的运算不可用
n << m -> 计算 n(2^m)，即乘以 2 的 m 次方
n >> m -> 计算 n/(2^m)，即除以 2 的 m 次方
1 << n -> 2^n
通过 ^ 快速交换两个整数。

a ^= b
b ^= a
a ^= b
通过 a & (-a) 快速获取a的最后为 1 位置的整数。

00 00 01 01 -> 5
&
11 11 10 11 -> -5
—
00 00 00 01 -> 1

00 00 11 10 -> 14
&
11 11 00 10 -> -14
—
00 00 00 10 -> 2

9. 利用位运算实现整数集合

一个数的二进制表示可以看作是一个集合（0 表示不在集合中，1 表示在集合中）。

比如集合 {1, 3, 4, 8}，可以表示成 01 00 01 10 10 而对应的位运算也就可以看作是对集合进行的操作。

元素与集合的操作：

a | (1< 把 i 插入到集合中
a & ~(1< 把 i 从集合中删除
a & (1< 判断 i 是否属于该集合（零不属于，非零属于）
集合之间的操作：

a 补 -> ~a
a 交 b -> a & b
a 并 b -> a | b
a 差 b -> a & (~b)
注意：整数在内存中是以补码的形式存在的，输出自然也是按照补码输出。

【例子】 Python 的bin() 输出。

print(bin(3))  # 0b11
print(bin(-3))  # -0b11

print(bin(-3 & 0xffffffff))  
# 0b11111111111111111111111111111101

print(bin(0xfffffffd))       
# 0b11111111111111111111111111111101

print(0xfffffffd)  # 4294967293

0b11
-0b11
0b11111111111111111111111111111101
0b11111111111111111111111111111101
4294967293

• Python中bin一个负数（十进制表示），输出的是它的原码的二进制表示加上个负号，啥也不是。
• Python中的整型是补码形式存储的。
• Python中整型是不限制长度的不会超范围溢出。
  所以为了获得负数（十进制表示）的补码，需要手动将其和十六进制数0xffffffff进行按位与操作，再交给bin()进行输出，得到的才是负数的补码表示。

练习题：

leetcode 习题 136. 只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

尝试使用位运算解决此题。

题目说明:

“”"
Input file
example1: [2,2,1]
example2: [4,1,2,1,2]

Output file
result1: 1
result2: 4
“”"

class Solution:
def singleNumber(self, nums: List[int]) -> int:

 # your code here  

还没想到，有一些思路是把数组中的数用二进制表示，然后根据位异或操作等应该能选出不一样的那个元素，但是由于对python的语法以及一些函数调用类数组的内容不太清楚，等先打个卡，之后再好好看看，下面是其他语言相关代码，以及注释掉了，只是方便我后面对照着改为python代码

'''
class Solution:
    def singleNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        nums.sort()
        for i in range(len(nums)):
            if len(nums) == 1:
                print nums[0]
            if nums[0] == nums[1]:
                del nums[0]
                del nums[0]
            else:
                print nums[0]
    '''

  File "", line 10
    print nums[0]
             ^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print(print nums[0])?

  File "", line 1
    class Solution {
                   ^
SyntaxError: invalid syntax