DeepOps的小笔记-程序员如何把控自己的职业重点总结

Leave a Comment / 程序员人生 / By piken

程序员如何把控自己的职业

上面是原文地址

开篇的三点总结

第一，需要大致知道这个世界的一些规律和发展趋势，另外还得认识自己

第二，打牢基础，以不变应万变

第三，提升成长的效率

1、人才分类

技工、特种工、工程师、设计师和架构人员、经理

2、认识自己

特长、兴趣、方法、勤奋

3、打好基础

哪些是基础？新技术变化的都是表面的东西，内在的原理没怎么变化。只要抓住原理，举一反三，如果只是学了个表面功夫，技术变化了还得再重头学习。

哪些是基础？

程序语言：语言原理、累哭的原理、编程技术（并发、异步等）、编程范式、设计模式… …

系统原理：计算机系统、操作系统、网络协议、数据库原理… …

中间件：消息队列、缓存系统、网管代理、调度系统… …

理论知识：算法和数据结构、数据库范式、网络的七层模型、分布式系统… …

4、学习经验

1、挑选一手知识和信息源。

2、注意原理和基础第二要注重基础原理。

3、使用知识图谱一定要学会使用知识图

4、学会举一反三。

5、总结和归纳。

6、实践和坚持。

5、学习效率

主动学习：教授给他人（费曼学习方法）（90%）、实践（75%）、讨论（50%）

被动学习：听讲（5%）、阅读（10%）、试听（20%）、演示（30%）

另外陈皓老师的极客时间专栏内容非常详尽和充实，在那里面也说到了这些内容，别上面的总结内容更加详尽。推荐订阅一把，这是我订阅的最值得专栏，看成编程人生索引

DeepOps的Jenkins小笔记-搭建jenkins

方式1：下载并运行 Jenkins

注意运行jenkins的jdk版本8或11

下载 Jenkins.
打开终端进入到下载目录.
运行命令 java -jar jenkins.war --httpPort=8080.
打开浏览器进入链接 http://localhost:8080.
按照说明完成安装.

http://localhost:8080/jks

方式2： docker安装jenkins

https://www.jenkins.io/doc/book/installing/

按顺序一路操作即可，如果有权限问题，加上sudo

docker network create jenkins
docker volume create jenkins-docker-certs
docker volume create jenkins-data

docker container run \
  --name jenkins-docker \
  --rm \
  --detach \
  --privileged \
  --network jenkins \
  --network-alias docker \
  --env DOCKER_TLS_CERTDIR=/certs \
  --volume jenkins-docker-certs:/certs/client \
  --volume jenkins-data:/var/jenkins_home \
  --publish 2376:2376 \
  docker:dind

docker container run \
  --name jenkins-blueocean \
  --rm \
  --detach \
  --network jenkins \
  --env DOCKER_HOST=tcp://docker:2376 \
  --env DOCKER_CERT_PATH=/certs/client \
  --env DOCKER_TLS_VERIFY=1 \
  --publish 8080:8080 \
  --publish 50000:50000 \
  --volume jenkins-data:/var/jenkins_home \
  --volume jenkins-docker-certs:/certs/client:ro \
  jenkinsci/blueocean

初始化jenkins

Unlocking Jenkins

When you first access a new Jenkins instance, you are asked to unlock it using an automatically-generated password.

Browse to http://localhost:8080 (or whichever port you configured for Jenkins when installing it) and wait until the Unlock Jenkins page appears.

Unlock Jenkins

To ensure Jenkins is securely set up by the administrator, a password has been written to the log (not sure where to find it?) and this file on the server:

最主要的就是找到这个密码，然后输入。另外根据提示下载插件，创建用户算是完成了基本设置。

使用war包安装：/var/jenkins_home/secrets/initialAdminPassword

使用docker 安装：/var/lib/docker/volumes/jenkins-data/_data/secrets/initialAdminPassword

Please copy the password from either location and paste it below.Administrator password

DeepOps的程序员数学小笔记-二进制

1 二进制

电路只有开、关两种状态。使用 0 、1 表示。十进制中 10 为基数，二进制中 2 为基数。

1.1 python 十进制转换为二进制、八进制、十六进制

# 十进制 --> 二进制
n2 = 17
r2 = bin(n2)   

# 十进制 --> 八进制
n8 = 17
r8 = oct(n8)   

# 十进制 --> 十六进制
n16 = 17
r16 = hex(n16) 

print(n2,' --> ',r2)  
print(n8,' --> ',r8)
print(n16,' --> ',r16)

#result：
17  -->  0b10001
17  -->  0o21
17  -->  0x11

1.2 python 二进制、八进制、十六进制转换为十进制

# 二进制 --> 十进制
s2 = '0b10001'
r2 = int(s2,base=2) 

# 八进制 --> 十进制
s8 = '0o21'
r8 = int(s8,base=8) 

# 十六进制 --> 十进制
s16 = '0x11'
r16 = int(s16,base=16) 

print(s2,' --> ',r2)  
print(s8,' --> ',r8)
print(s16,' --> ',r16)

#result：
0b10001  -->  17
0o21  -->  17
0x11  -->  17

1.3 其他一些用法

s = '11'
r1 = int(s,base=16) # 16进制 可以不加0x
r2 = int(s,base=9)  # 9进制 转换为 10进制

print(s,' --> ',r1) 
print(s,' --> ',r2)

#result：
11  -->  17
11  -->  10

2 二进制的位操作

2.1 向左移位

# 正数
n=26
print(n)
print(bin(n))
n2=n<<2       # 左移2位
print(n2)
print(bin(n2))

n3=n<<60
print(n3)
print(bin(n3))
# 负数
n=-26
print(n)
print(bin(n))
n2=n<<2
print(n2)
print(bin(n2))

n3=n<<60
print(n3)
print(bin(n3))

#result：
26
0b11010
104
0b1101000
29975959119778021376
0b11010000000000000000000000000000000000000000000000000000000000000
-26
-0b11010
-104
-0b1101000
-29975959119778021376
-0b11010000000000000000000000000000000000000000000000000000000000000

2.2 向右移位

右移操作区分：算术右移逻辑右移。逻辑右移使用>>>（python中无逻辑右移操作符，没有java重编码测试），右移后左边补0；算术右移使用>>，右移后，符号位右侧补1。负数采用补码方式记录。

# 正数
n=53
print(n)
print(bin(n))
n2=n>>1
print(n2)
print(bin(n2))
n3=n>>7
print(n3)
print(bin(n3))
# 负数
n=-53
print(n)
print(bin(n))
n2=n>>1
print(n2)
print(bin(n2))
n3=n>>7
print(n3)
print(bin(n3))

#result
53
0b110101
26
0b11010
0
0b0

-53
-0b110101
-27
-0b11011
-1
-0b1

2.3 位的“或”、“与”、“异或”、非

a = 60
b = 13
print('a:',bin(a))
print('b:',bin(b))


print('a&b:',bin(a&b))
print('a|b:',bin(a|b))
print('a^b:',bin(a^b))
print('~a:',bin(~a))

a1=-60
print('a1:',bin(a1))
print('~a1:',bin(~a1))

result：
a: 0b111100
b: 0b1101

a&b: 0b1100
a|b: 0b111101
a^b: 0b110001
~a: -0b111101

a1: -0b111100
~a1: 0b111011

3 原码、反码和补码

参考：https://www.cnblogs.com/zhangziqiu/archive/2011/03/30/ComputerCode.html

原码
原码就是符号位加上真值的绝对值, 即用第一位表示符号, 其余位表示值. 比如如果是8位二进制:
[+1]原 = 0000 0001
[-1]原 = 1000 0001
第一位是符号位. 因为第一位是符号位, 所以8位二进制数的取值范围就是:[1111 1111 , 0111 1111]，即[-127 , 127]

反码
反码的表示方法是:
正数的反码是其本身
负数的反码是在其原码的基础上, 符号位不变，其余各个位取反.
[+1] = [00000001]原 = [00000001]反
[-1] = [10000001]原 = [11111110]反

补码
补码的表示方法是:
正数的补码就是其本身
负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)
[+1] = [00000001]原 = [00000001]反 = [00000001]补
[-1] = [10000001]原 = [11111110]反 = [11111111]补

反码解决 1-1=0 的问题：

1 – 1 = 1 + (-1) = [0000 0001]_原 + [1000 0001]_原= [0000 0001]_反 + [1111 1110]_反 = [1111 1111]_反 = [1000 0000]_原 = -0

补码解决了反码相加等于 -0 的问题：

1-1 = 1 + (-1) = [0000 0001]_原 + [1000 0001]_原 = [0000 0001]_补 + [1111 1111]_补 = [0000 0000]_补=[0000 0000]_原

参考资料：

极客时间-程序员的数学基础课
结城浩-程序员的数学

下面是极客时间的该课程快捷入口：

15 个提高效率的 Python 编程技巧（转）

1. 交换值

x, y = 1, 2
print(x, y)
x, y = y, x
print(x, y)

2. 字符串列表合并为一个字符串

sentence_list = ["my", "name", "is", "George"]
sentence_string = " ".join(sentence_list)
print(sentence_string)

3. 将字符串拆分为子字符串列表

sentence_string = "my name is George"
sentence_string.split()
print(sentence_string)

4. 通过数字填充初始化列表

[0]*1000 # List of 1000 zeros 
[8.2]*1000 # List of 1000 8.2's

5. 字典合并

x = {'a': 1, 'b': 2}
y = {'b': 3, 'c': 4}
z = {**x, **y}

6. 反转字符串

name = "George"
name[::-1]

7. 从函数返回多个值

def get_a_string():
  a = "George"
  b = "is"
  c = "cool"
  return a, b, c
sentence = get_a_string()
(a, b, c) = sentence

8. 列表解析式

a = [1, 2, 3]
b = [num*2 for num in a] # Create a new list by multiplying each element in a by 2

9. 遍历字典

m = {'a': 1, 'b': 2, 'c': 3, 'd': 4} 
for key, value in m.items():
  print('{0}: {1}'.format(key, value))

10. 同时遍历列表的索引和值

m = ['a', 'b', 'c', 'd']
for index, value in enumerate(m):
  print('{0}: {1}'.format(index, value))

11. 初始化空容器

a_list = list()
a_dict = dict()
a_map = map()
a_set = set()

12. 删除字符串两端的无用字符

name = "  George "
name_2 = "George///"
name.strip() # prints "George"
name_2.strip("/") # prints "George"

13. 列表中出现最多的元素

test = [1, 2, 3, 4, 2, 2, 3, 1, 4, 4, 4]
print(max(set(test), key = test.count))

14. 检查对象的内存使用情况

import sys
x = 1
print(sys.getsizeof(x))

15. 将 dict 转换为 XML

from xml.etree.ElementTree import Element
def dict_to_xml(tag, d):
    '''
    Turn a simple dict of key/value pairs into XML
    '''
    elem = Element(tag)
    for key, val in d.items():
        child = Element(key)
        child.text = str(val)
        elem.append(child)
    return elem

计算机